(function () {

    var jQuery = window.jQuery,
        undefined, _, //temp variable of prototypes
        mqCmdId = 'mathquill-command-id',
        mqBlockId = 'mathquill-block-id',
        min = Math.min,
        max = Math.max,
        blockmatrixTemp=[],
        sizematrix=0,
        matrixString=''
        sizecases=0,
        caseString='';

    var __slice = [].slice;

    function noop() {}

    /**
     * sugar to make defining lots of commands easier.
     * TODO: rethink this.
     */

    function bind(cons /*, args... */ ) {
        var args = __slice.call(arguments, 1);
        return function () {
            return cons.apply(this, args);
        };
    }

    /**
     * a development-only debug method.  This definition and all
     * calls to `pray` will be stripped from the minified
     * build of mathquill.
     *
     * This function must be called by name to be removed
     * at compile time.  Do not define another function
     * with the same name, and only call this function by
     * name.
     */

    function pray(message, cond) {
        if (!cond) throw new Error('prayer failed: ' + message);
    }
    var P = (function (prototype, ownProperty, undefined) {
        // helper functions that also help minification


        function isObject(o) {
            return typeof o === 'object';
        }

        function isFunction(f) {
            return typeof f === 'function';
        }

        // a function that gets reused to make uninitialized objects


        function BareConstructor() {}

        function P(_superclass /* = Object */ , definition) {
            // handle the case where no superclass is given
            if (definition === undefined) {
                definition = _superclass;
                _superclass = Object;
            }

            // C is the class to be returned.
            //
            // It delegates to instantiating an instance of `Bare`, so that it
            // will always return a new instance regardless of the calling
            // context.
            //
            //  TODO: the Chrome inspector shows all created objects as `C`
            //        rather than `Object`.  Setting the .name property seems to
            //        have no effect.  Is there a way to override this behavior?


            function C() {
                var self = new Bare;
                if (isFunction(self.init)) self.init.apply(self, arguments);
                return self;
            }

            // C.Bare is a class with a noop constructor.  Its prototype is the
            // same as C, so that instances of C.Bare are also instances of C.
            // New objects can be allocated without initialization by calling
            // `new MyClass.Bare`.


            function Bare() {}
            C.Bare = Bare;

            // Set up the prototype of the new class.
            var _super = BareConstructor[prototype] = _superclass[prototype];
            var proto = Bare[prototype] = C[prototype] = new BareConstructor;

            // other variables, as a minifier optimization
            var extensions;


            // set the constructor property on the prototype, for convenience
            proto.constructor = C;

            C.mixin = function (def) {
                Bare[prototype] = C[prototype] = P(C, def)[prototype];
                return C;
            }

            return (C.open = function (def) {
                extensions = {};

                if (isFunction(def)) {
                    // call the defining function with all the arguments you need
                    // extensions captures the return value.
                    extensions = def.call(C, proto, _super, C, _superclass);
                } else if (isObject(def)) {
                    // if you passed an object instead, we'll take it
                    extensions = def;
                }

                // ...and extend it
                if (isObject(extensions)) {
                    for (var ext in extensions) {
                        if (ownProperty.call(extensions, ext)) {
                            proto[ext] = extensions[ext];
                        }
                    }
                }

                // if there's no init, we assume we're inheriting a non-pjs class, so
                // we default to applying the superclass's constructor.
                if (!isFunction(proto.init)) {
                    proto.init = _superclass;
                }

                return C;
            })(definition);
        }

        // ship it
        return P;

        // as a minifier optimization, we've closured in a few helper functions
        // and the string 'prototype' (C[p] is much shorter than C.prototype)
    })('prototype', ({}).hasOwnProperty);
    /*************************************************
     * Textarea Manager
     *
     * An abstraction layer wrapping the textarea in
     * an object with methods to manipulate and listen
     * to events on, that hides all the nasty cross-
     * browser incompatibilities behind a uniform API.
     *
     * Design goal: This is a *HARD* internal
     * abstraction barrier. Cross-browser
     * inconsistencies are not allowed to leak through
     * and be dealt with by event handlers. All future
     * cross-browser issues that arise must be dealt
     * with here, and if necessary, the API updated.
     *
     * Organization:
     * - key values map and stringify()
     * - manageTextarea()
     *    + defer() and flush()
     *    + event handler logic
     *    + attach event handlers and export methods
     ************************************************/

    var manageTextarea = (function () {
        // The following [key values][1] map was compiled from the
        // [DOM3 Events appendix section on key codes][2] and
        // [a widely cited report on cross-browser tests of key codes][3],
        // except for 10: 'Enter', which I've empirically observed in Safari on iOS
        // and doesn't appear to conflict with any other known key codes.
        //
        // [1]: http://www.w3.org/TR/2012/WD-DOM-Level-3-Events-20120614/#keys-keyvalues
        // [2]: http://www.w3.org/TR/2012/WD-DOM-Level-3-Events-20120614/#fixed-virtual-key-codes
        // [3]: http://unixpapa.com/js/key.html
        var KEY_VALUES = {
            8: 'Backspace',
            9: 'Tab',

            10: 'Enter',
            // for Safari on iOS
            13: 'Enter',


            16: 'Shift',
            17: 'Control',
            18: 'Alt',
            20: 'CapsLock',

            27: 'Esc',


           
            33: 'PageUp',
            34: 'PageDown',
            35: 'End',
            36: 'Home',

            37: 'Left',
            38: 'Up',
            39: 'Right',
            40: 'Down',

            45: 'Insert',

            46: 'Del',

            144: 'NumLock'
        };

        // To the extent possible, create a normalized string representation
        // of the key combo (i.e., key code and modifier keys).


        function stringify(evt) {
            var which = evt.which || evt.keyCode;
            var keyVal = KEY_VALUES[which];
            var key;
            var modifiers = [];

            if (evt.ctrlKey) modifiers.push('Ctrl');
            if (evt.originalEvent && evt.originalEvent.metaKey) modifiers.push('Meta');
            if (evt.altKey) modifiers.push('Alt');
            if (evt.shiftKey) modifiers.push('Shift');

            key = keyVal || String.fromCharCode(which);

            if (!modifiers.length && !keyVal) return key;

            modifiers.push(key);
            return modifiers.join('-');
        }

        // create a textarea manager that calls callbacks at useful times
        // and exports useful public methods
        return function manageTextarea(el, opts) {
            var keydown = null;
            var keypress = null;

            if (!opts) opts = {};
            var textCallback = opts.text || noop;
            var keyCallback = opts.key || noop;
            var pasteCallback = opts.paste || noop;
            var onCut = opts.cut || noop;

            var textarea = jQuery(el);
            var target = jQuery(opts.container || textarea);

            // checkTextareaFor() is called after keypress or paste events to
            // say "Hey, I think something was just typed" or "pasted" (resp.),
            // so that at all subsequent opportune times (next event or timeout),
            // will check for expected typed or pasted text.
            // Need to check repeatedly because #135: in Safari 5.1 (at least),
            // after selecting something and then typing, the textarea is
            // incorrectly reported as selected during the input event (but not
            // subsequently).
            var checkTextarea = noop,
                timeoutId;

            function checkTextareaFor(checker) {
                checkTextarea = checker;
                clearTimeout(timeoutId);
                timeoutId = setTimeout(checker);
            }
            target.bind('keydown keypress input keyup focusout paste', function () {
                checkTextarea();
            });


            // -*- public methods -*- //


            function select(text) {
                // check textarea at least once/one last time before munging (so
                // no race condition if selection happens after keypress/paste but
                // before checkTextarea), then never again ('cos it's been munged)
                checkTextarea();
                checkTextarea = noop;
                clearTimeout(timeoutId);

                textarea.val(text);
                if (text) textarea[0].select();
            }

            // -*- helper subroutines -*- //
            // Determine whether there's a selection in the textarea.
            // This will always return false in IE < 9, which don't support
            // HTMLTextareaElement::selection{Start,End}.


            function hasSelection() {
                var dom = textarea[0];

                if (!('selectionStart' in dom)) return false;
                return dom.selectionStart !== dom.selectionEnd;
            }

            function popText(callback) {
                var text = textarea.val();
                textarea.val('');
                if (text) callback(text);
            }

            function handleKey() {
                keyCallback(stringify(keydown), keydown);
            }

            // -*- event handlers -*- //


            function onKeydown(e) {
                keydown = e;
                keypress = null;

                handleKey();
            }

            function onKeypress(e) {
                // call the key handler for repeated keypresses.
                // This excludes keypresses that happen directly
                // after keydown.  In that case, there will be
                // no previous keypress, so we skip it here
                if (keydown && keypress) handleKey();

                keypress = e;

                checkTextareaFor(typedText);
            }

            function typedText() {
                // If there is a selection, the contents of the textarea couldn't
                // possibly have just been typed in.
                // This happens in browsers like Firefox and Opera that fire
                // keypress for keystrokes that are not text entry and leave the
                // selection in the textarea alone, such as Ctrl-C.
                // Note: we assume that browsers that don't support hasSelection()
                // also never fire keypress on keystrokes that are not text entry.
                // This seems reasonably safe because:
                // - all modern browsers including IE 9+ support hasSelection(),
                //   making it extremely unlikely any browser besides IE < 9 won't
                // - as far as we know IE < 9 never fires keypress on keystrokes
                //   that aren't text entry, which is only as reliable as our
                //   tests are comprehensive, but the IE < 9 way to do
                //   hasSelection() is poorly documented and is also only as
                //   reliable as our tests are comprehensive
                // If anything like #40 or #71 is reported in IE < 9, see
                // b1318e5349160b665003e36d4eedd64101ceacd8
                if (hasSelection()) return;

                popText(textCallback);
            }

            function onBlur() {
                keydown = keypress = null;
            }

            function onPaste(e) {
                // browsers are dumb.
                //
                // In Linux, middle-click pasting causes onPaste to be called,
                // when the textarea is not necessarily focused.  We focus it
                // here to ensure that the pasted text actually ends up in the
                // textarea.
                //
                // It's pretty nifty that by changing focus in this handler,
                // we can change the target of the default action.  (This works
                // on keydown too, FWIW).
                //
                // And by nifty, we mean dumb (but useful sometimes).
                textarea.focus();

                checkTextareaFor(pastedText);
            }

            function pastedText() {
                popText(pasteCallback);
            }

            // -*- attach event handlers -*- //
            target.bind({
                keydown: onKeydown,
                keypress: onKeypress,
                focusout: onBlur,
                cut: onCut,
                paste: onPaste
            });

            // -*- export public methods -*- //
            return {
                select: select
            };
        };
    }());
    var Parser = P(function (_, _super, Parser) {
        // The Parser object is a wrapper for a parser function.
        // Externally, you use one to parse a string by calling
        //   var result = SomeParser.parse('Me Me Me! Parse Me!');
        // You should never call the constructor, rather you should
        // construct your Parser from the base parsers and the
        // parser combinator methods.

        function parseError(stream, message) {
            if (stream) {
                stream = "'" + stream + "'";
            } else {
                stream = 'EOF';
            }

            throw 'Parse Error: ' + message + ' at ' + stream;
        }

        _.init = function (body) {
            this._ = body;
        };

        _.parse = function (stream) {
            return this.skip(eof)._(stream, success, parseError);

            function success(stream, result) {
                return result;
            }
        };

        // -*- primitive combinators -*- //
        _.or = function (alternative) {
            pray('or is passed a parser', alternative instanceof Parser);

            var self = this;

            return Parser(function (stream, onSuccess, onFailure) {
                return self._(stream, onSuccess, failure);

                function failure(newStream) {
                    return alternative._(stream, onSuccess, onFailure);
                }
            });
        };

        _.then = function (next) {
            var self = this;

            return Parser(function (stream, onSuccess, onFailure) {
                return self._(stream, success, onFailure);

                function success(newStream, result) {
                    var nextParser = (next instanceof Parser ? next : next(result));
                    pray('a parser is returned', nextParser instanceof Parser);
                    return nextParser._(newStream, onSuccess, onFailure);
                }
            });
        };

        // -*- optimized iterative combinators -*- //
        _.many = function () {
            var self = this;

            return Parser(function (stream, onSuccess, onFailure) {
                var xs = [];
                while (self._(stream, success, failure));
                return onSuccess(stream, xs);

                function success(newStream, x) {
                    stream = newStream;
                    xs.push(x);
                    return true;
                }

                function failure() {
                    return false;
                }
            });
        };

        _.times = function (min, max) {
            if (arguments.length < 2) max = min;
            var self = this;

            return Parser(function (stream, onSuccess, onFailure) {
                var xs = [];
                var result = true;
                var failure;

                for (var i = 0; i < min; i += 1) {
                    result = self._(stream, success, firstFailure);
                    if (!result) return onFailure(stream, failure);
                }

                for (; i < max && result; i += 1) {
                    result = self._(stream, success, secondFailure);
                }

                return onSuccess(stream, xs);

                function success(newStream, x) {
                    xs.push(x);
                    stream = newStream;
                    return true;
                }

                function firstFailure(newStream, msg) {
                    failure = msg;
                    stream = newStream;
                    return false;
                }

                function secondFailure(newStream, msg) {
                    return false;
                }
            });
        };

        // -*- higher-level combinators -*- //
        _.result = function (res) {
            return this.then(succeed(res));
        };
        _.atMost = function (n) {
            return this.times(0, n);
        };
        _.atLeast = function (n) {
            var self = this;
            return self.times(n).then(function (start) {
                return self.many().map(function (end) {
                    return start.concat(end);
                });
            });
        };

        _.map = function (fn) {
            return this.then(function (result) {
                return succeed(fn(result));
            });
        };

        _.skip = function (two) {
            return this.then(function (result) {
                return two.result(result);
            });
        };

        _.lstream = function () {
            return stream;
        };

        // -*- primitive parsers -*- //
        var string = this.string = function (str) {
                var len = str.length;
                var expected = "expected '" + str + "'";

                return Parser(function (stream, onSuccess, onFailure) {
                    var head = stream.slice(0, len);

                    if (head === str) {
                        return onSuccess(stream.slice(len), head);
                    } else {
                        return onFailure(stream, expected);
                    }
                });
            };

        var regex = this.regex = function (re) {
                pray('regexp parser is anchored', re.toString().charAt(1) === '^');

                var expected = 'expected ' + re;

                return Parser(function (stream, onSuccess, onFailure) {
                    var match = re.exec(stream);

                    if (match) {
                        var result = match[0];
                        return onSuccess(stream.slice(result.length), result);
                    } else {
                        return onFailure(stream, expected);
                    }
                });
            };

        var succeed = Parser.succeed = function (result) {
                return Parser(function (stream, onSuccess) {
                    return onSuccess(stream, result);
                });
            };

        var fail = Parser.fail = function (msg) {
                return Parser(function (stream, _, onFailure) {
                    return onFailure(stream, msg);
                });
            };

        var letter = Parser.letter = regex(/^[a-z]/i);
        var letters = Parser.letters = regex(/^[a-z]*/i);
        var digit = Parser.digit = regex(/^[0-9]/);
        var digits = Parser.digits = regex(/^[0-9]*/);
        var whitespace = Parser.whitespace = regex(/^\s+/);
        var optWhitespace = Parser.optWhitespace = regex(/^\s*/);

        var any = Parser.any = Parser(function (stream, onSuccess, onFailure) {
            if (!stream) return onFailure(stream, 'expected any character');

            return onSuccess(stream.slice(1), stream.charAt(0));
        });

        var all = Parser.all = Parser(function (stream, onSuccess, onFailure) {
            return onSuccess('', stream);
        });

        var eof = Parser.eof = Parser(function (stream, onSuccess, onFailure) {
            if (stream) return onFailure(stream, 'expected EOF');

            return onSuccess(stream, stream);
        });
    });
    /*************************************************
     * Base classes of the MathQuill virtual DOM tree
     *
     * Only doing tree node manipulation via these
     * adopt/ disown methods guarantees well-formedness
     * of the tree.
     ************************************************/

    // L = 'left'
    // R = 'right'
    //
    // the contract is that they can be used as object properties
    // and (-L) === R, and (-R) === L.
    var L = -1;
    var R = 1;

    function prayDirection(dir) {
        pray('a direction was passed', dir === L || dir === R);
    }

    /**
     * Tiny extension of jQuery adding directionalized DOM manipulation methods.
     *
     * Funny how Pjs v3 almost just works with `jQuery.fn.init`.
     *
     * jQuery features that don't work on $:
     *   - jQuery.*, like jQuery.ajax, obviously (Pjs doesn't and shouldn't
     *                                            copy constructor properties)
     *
     *   - jQuery(function), the shortcut for `jQuery(document).ready(function)`,
     *     because `jQuery.fn.init` is idiosyncratic and Pjs doing, essentially,
     *     `jQuery.fn.init.apply(this, arguments)` isn't quite right, you need:
     *
     *       _.init = function(s, c) { jQuery.fn.init.call(this, s, c, $(document)); };
     *
     *     if you actually give a shit (really, don't bother),
     *     see https://github.com/jquery/jquery/blob/1.7.2/src/core.js#L889
     *
     *   - jQuery(selector), because jQuery translates that to
     *     `jQuery(document).find(selector)`, but Pjs doesn't (should it?) let
     *     you override the result of a constructor call
     *       + note that because of the jQuery(document) shortcut-ness, there's also
     *         the 3rd-argument-needs-to-be-`$(document)` thing above, but the fix
     *         for that (as can be seen above) is really easy. This problem requires
     *         a way more intrusive fix
     *
     * And that's it! Everything else just magically works because jQuery internally
     * uses `this.constructor()` everywhere (hence calling `$`), but never ever does
     * `this.constructor.find` or anything like that, always doing `jQuery.find`.
     */
    var $ = P(jQuery, function (_) {
        _.insDirOf = function (dir, el) {
            return dir === L ? this.insertBefore(el.first()) : this.insertAfter(el.last());
        };
        _.insAtDirEnd = function (dir, el) {
            return dir === L ? this.prependTo(el) : this.appendTo(el);
        };
    });

    var Point = P(function (_) {
        _.parent = 0;
        _[L] = 0;
        _[R] = 0;

        _.init = function (parent, leftward, rightward) {
            this.parent = parent;
            this[L] = leftward;
            this[R] = rightward;
        };
    });

    /**
     * MathQuill virtual-DOM tree-node abstract base class
     */
    var Node = P(function (_) {
        _[L] = 0;
        _[R] = 0
        _.parent = 0;

        _.init = function () {
            this.ends = {};
            this.ends[L] = 0;
            this.ends[R] = 0;
        };

        _.children = function () {
            return Fragment(this.ends[L], this.ends[R]);
        };

        _.eachChild = function (fn) {
            return this.children().each(fn);
        };

        _.foldChildren = function (fold, fn) {
            return this.children().fold(fold, fn);
        };

        _.adopt = function (parent, leftward, rightward) {
            Fragment(this, this).adopt(parent, leftward, rightward);
            return this;
        };

        _.disown = function () {
            Fragment(this, this).disown();
            return this;
        };
    });

    /**
     * An entity outside the virtual tree with one-way pointers (so it's only a
     * "view" of part of the tree, not an actual node/entity in the tree) that
     * delimits a doubly-linked list of sibling nodes.
     * It's like a fanfic love-child between HTML DOM DocumentFragment and the Range
     * classes: like DocumentFragment, its contents must be sibling nodes
     * (unlike Range, whose contents are arbitrary contiguous pieces of subtrees),
     * but like Range, it has only one-way pointers to its contents, its contents
     * have no reference to it and in fact may still be in the visible tree (unlike
     * DocumentFragment, whose contents must be detached from the visible tree
     * and have their 'parent' pointers set to the DocumentFragment).
     */
    var Fragment = P(function (_) {
        _.init = function (leftEnd, rightEnd) {
            pray('no half-empty fragments', !leftEnd === !rightEnd);

            this.ends = {};

            if (!leftEnd) return;

            pray('left end node is passed to Fragment', leftEnd instanceof Node);
            pray('right end node is passed to Fragment', rightEnd instanceof Node);
            pray('leftEnd and rightEnd have the same parent', leftEnd.parent === rightEnd.parent);

            this.ends[L] = leftEnd;
            this.ends[R] = rightEnd;
        };

        function prayWellFormed(parent, leftward, rightward) {
            pray('a parent is always present', parent);
            pray('leftward is properly set up', (function () {
                // either it's empty and `rightward` is the left end child (possibly empty)
                if (!leftward) return parent.ends[L] === rightward;

                // or it's there and its [R] and .parent are properly set up
                return leftward[R] === rightward && leftward.parent === parent;
            })());

            pray('rightward is properly set up', (function () {
                // either it's empty and `leftward` is the right end child (possibly empty)
                if (!rightward) return parent.ends[R] === leftward;

                // or it's there and its [L] and .parent are properly set up
                return rightward[L] === leftward && rightward.parent === parent;
            })());
        }

        _.adopt = function (parent, leftward, rightward) {
            prayWellFormed(parent, leftward, rightward);

            var self = this;
            self.disowned = false;

            var leftEnd = self.ends[L];
            if (!leftEnd) return this;

            var rightEnd = self.ends[R];

            if (leftward) {
                // NB: this is handled in the ::each() block
                // leftward[R] = leftEnd
            } else {
                parent.ends[L] = leftEnd;
            }

            if (rightward) {
                rightward[L] = rightEnd;
            } else {
                parent.ends[R] = rightEnd;
            }

            self.ends[R][R] = rightward;

            self.each(function (el) {
                el[L] = leftward;
                el.parent = parent;
                if (leftward) leftward[R] = el;

                leftward = el;
            });

            return self;
        };

        _.disown = function () {
            var self = this;
            var leftEnd = self.ends[L];

            // guard for empty and already-disowned fragments
            if (!leftEnd || self.disowned) return self;

            self.disowned = true;

            var rightEnd = self.ends[R]
            var parent = leftEnd.parent;

            prayWellFormed(parent, leftEnd[L], leftEnd);
            prayWellFormed(parent, rightEnd, rightEnd[R]);

            if (leftEnd[L]) {
                leftEnd[L][R] = rightEnd[R];
            } else {
                parent.ends[L] = rightEnd[R];
            }

            if (rightEnd[R]) {
                rightEnd[R][L] = leftEnd[L];
            } else {
                parent.ends[R] = leftEnd[L];
            }

            return self;
        };

        _.each = function (fn) {
            var self = this;
            var el = self.ends[L];
            if (!el) return self;

            for (; el !== self.ends[R][R]; el = el[R]) {
                if (fn.call(self, el) === false) break;
            }

            return self;
        };

        _.fold = function (fold, fn) {
            this.each(function (el) {
                fold = fn.call(this, fold, el);
            });

            return fold;
        };
    });
    /*************************************************
     * Abstract classes of math blocks and commands.
     ************************************************/

    var uuid = (function () {
        var id = 0;

        return function () {
            return id += 1;
        };
    })();

    /**
     * Math tree node base class.
     * Some math-tree-specific extensions to Node.
     * Both MathBlock's and MathCommand's descend from it.
     */
    var MathElement = P(Node, function (_, _super) {
        _.init = function (obj) {
            _super.init.call(this);
            this.id = uuid();
            MathElement[this.id] = this;
        };

        _.toString = function () {
            return '[MathElement ' + this.id + ']';
        };

        _.bubble = function (event /*, args... */ ) {
            var args = __slice.call(arguments, 1);

            for (var ancestor = this; ancestor; ancestor = ancestor.parent) {
                var res = ancestor[event] && ancestor[event].apply(ancestor, args);
                if (res === false) break;
            }

            return this;
        };

        _.postOrder = function (fn /*, args... */ ) {
            var args = __slice.call(arguments, 1);

            if (typeof fn === 'string') {
                var methodName = fn;
                fn = function (el) {
                    if (methodName in el) el[methodName].apply(el, args);
                };
            }

            (function recurse(desc) {
                desc.eachChild(recurse);
                fn(desc);
            })(this);
        };

        _.jQ = $();
        _.jQadd = function (jQ) {
            this.jQ = this.jQ.add(jQ);
        };

        this.jQize = function (html) {
            // Sets the .jQ of the entire math subtree rooted at this command.
            // Expects .createBlocks() to have been called already, since it
            // calls .html().
            var jQ = $(html);
            jQ.find('*').andSelf().each(function () {
                var jQ = $(this),
                    cmdId = jQ.attr('mathquill-command-id'),
                    blockId = jQ.attr('mathquill-block-id');
                if (cmdId) MathElement[cmdId].jQadd(jQ);
                if (blockId) MathElement[blockId].jQadd(jQ);
            });
            return jQ;
        };

        _.finalizeInsert = function () {
            var self = this;
            self.postOrder('finalizeTree');

            // note: this order is important.
            // empty elements need the empty box provided by blur to
            // be present in order for their dimensions to be measured
            // correctly in redraw.
            self.postOrder('blur');

            // adjust context-sensitive spacing
            self.postOrder('respace');
            if (self[R].respace) self[R].respace();
            if (self[L].respace) self[L].respace();

            self.postOrder('redraw');
            self.bubble('redraw');
        };
    });

    /**
     * Commands and operators, like subscripts, exponents, or fractions.
     * Descendant commands are organized into blocks.
     */
    var MathCommand = P(MathElement, function (_, _super) {
        _.init = function (ctrlSeq, htmlTemplate, textTemplate) {
            var cmd = this;
            _super.init.call(cmd);

            if (!cmd.ctrlSeq) cmd.ctrlSeq = ctrlSeq;
            if (htmlTemplate) cmd.htmlTemplate = htmlTemplate;
            if (textTemplate) cmd.textTemplate = textTemplate;
        };

        // obvious methods
        _.replaces = function (replacedFragment) {
            replacedFragment.disown();
            this.replacedFragment = replacedFragment;
        };
        _.isEmpty = function () {
            return this.foldChildren(true, function (isEmpty, child) {
                return isEmpty && child.isEmpty();
            });
        };

        _.parser = function () {
            var block = latexMathParser.block;
            var self = this;

            return block.times(self.numBlocks()).map(function (blocks) {
                self.blocks = blocks;

                for (var i = 0; i < blocks.length; i += 1) {
                    blocks[i].adopt(self, self.ends[R], 0);
                }

                return self;
            });
        };

        // createLeftOf(cursor) and the methods it calls
        _.createLeftOf = function (cursor) {
            var cmd = this;
            var replacedFragment = cmd.replacedFragment;

            cmd.createBlocks();
            MathElement.jQize(cmd.html());
            if (replacedFragment) {
                replacedFragment.adopt(cmd.ends[L], 0, 0);
                replacedFragment.jQ.appendTo(cmd.ends[L].jQ);
            }

            cursor.jQ.before(cmd.jQ);
            cursor[L] = cmd.adopt(cursor.parent, cursor[L], cursor[R]);

            cmd.finalizeInsert(cursor);

            cmd.placeCursor(cursor);
        };
        _.createBlocks = function () {
            var cmd = this,
                numBlocks = cmd.numBlocks(),
                blocks = cmd.blocks = Array(numBlocks);

            for (var i = 0; i < numBlocks; i += 1) {
                var newBlock = blocks[i] = MathBlock();
                newBlock.adopt(cmd, cmd.ends[R], 0);
            }
        };
        _.respace = noop; //placeholder for context-sensitive spacing
        _.placeCursor = function (cursor) {
            //insert the cursor at the right end of the first empty child, searching
            //left-to-right, or if none empty, the right end child
            cursor.insAtRightEnd(this.foldChildren(this.ends[L], function (leftward, child) {
                return leftward.isEmpty() ? leftward : child;
            }));
        };

        // remove()
        _.remove = function () {
            this.disown();
            this.jQ.remove();

            this.postOrder(function (el) {
                delete MathElement[el.id];
            });

            return this;
        };

        // methods involved in creating and cross-linking with HTML DOM nodes
/*
          They all expect an .htmlTemplate like
            '<span>&0</span>'
          or
            '<span><span>&0</span><span>&1</span></span>'
      
          See html.test.js for more examples.
      
          Requirements:
          - For each block of the command, there must be exactly one "block content
            marker" of the form '&<number>' where <number> is the 0-based index of the
            block. (Like the LaTeX \newcommand syntax, but with a 0-based rather than
            1-based index, because JavaScript because C because Dijkstra.)
          - The block content marker must be the sole contents of the containing
            element, there can't even be surrounding whitespace, or else we can't
            guarantee sticking to within the bounds of the block content marker when
            mucking with the HTML DOM.
          - The HTML not only must be well-formed HTML (of course), but also must
            conform to the XHTML requirements on tags, specifically all tags must
            either be self-closing (like '<br/>') or come in matching pairs.
            Close tags are never optional.
      
          Note that &<number> isn't well-formed HTML; if you wanted a literal '&123',
          your HTML template would have to have '&amp;123'.
        */
        _.numBlocks = function () {
            var matches = this.htmlTemplate.match(/&\d+/g);
            return matches ? matches.length : 0;
        };
        _.html = function () {
            // Render the entire math subtree rooted at this command, as HTML.
            // Expects .createBlocks() to have been called already, since it uses the
            // .blocks array of child blocks.
            //
            // See html.test.js for example templates and intended outputs.
            //
            // Given an .htmlTemplate as described above,
            // - insert the mathquill-command-id attribute into all top-level tags,
            //   which will be used to set this.jQ in .jQize().
            //   This is straightforward:
            //     * tokenize into tags and non-tags
            //     * loop through top-level tokens:
            //         * add #cmdId attribute macro to top-level self-closing tags
            //         * else add #cmdId attribute macro to top-level open tags
            //             * skip the matching top-level close tag and all tag pairs
            //               in between
            // - for each block content marker,
            //     + replace it with the contents of the corresponding block,
            //       rendered as HTML
            //     + insert the mathquill-block-id attribute into the containing tag
            //   This is even easier, a quick regex replace, since block tags cannot
            //   contain anything besides the block content marker.
            //
            // Two notes:
            // - The outermost loop through top-level tokens should never encounter any
            //   top-level close tags, because we should have first encountered a
            //   matching top-level open tag, all inner tags should have appeared in
            //   matching pairs and been skipped, and then we should have skipped the
            //   close tag in question.
            // - All open tags should have matching close tags, which means our inner
            //   loop should always encounter a close tag and drop nesting to 0. If
            //   a close tag is missing, the loop will continue until i >= tokens.length
            //   and token becomes undefined. This will not infinite loop, even in
            //   production without pray(), because it will then TypeError on .slice().
            var cmd = this;
            var blocks = cmd.blocks;
            var cmdId = ' mathquill-command-id=' + cmd.id;
            if(sizematrix>1&&cmd.ctrlSeq==='\\matrix'){
                var matrix=matrixString.substring(0,matrixString.indexOf('\/table>')+7);
                matrixString=matrixString.substring(matrixString.indexOf('\/table>')+7);
                cmd.htmlTemplate=   matrix;
            }
            if(sizecases>1&&cmd.ctrlSeq==='\\cases'){
                var cases=caseString.substring(0,caseString.indexOf('\/table>')+7);
                caseString=caseString.substring(caseString.indexOf('\/table>')+7);
                cmd.htmlTemplate=   cases;
            }
            var tokens = cmd.htmlTemplate.match(/<[^<>]+>|[^<>]+/g);

            pray('no unmatched angle brackets', tokens.join('') === this.htmlTemplate);

            // add cmdId to all top-level tags
            for (var i = 0, token = tokens[0]; token; i += 1, token = tokens[i]) {
                // top-level self-closing tags
                if (token.slice(-2) === '/>') {
                    tokens[i] = token.slice(0, -2) + cmdId + '/>';
                }
                // top-level open tags
                else if (token.charAt(0) === '<') {
                    pray('not an unmatched top-level close tag', token.charAt(1) !== '/');

                    tokens[i] = token.slice(0, -1) + cmdId + '>';

                    // skip matching top-level close tag and all tag pairs in between
                    var nesting = 1;
                    do {
                        i += 1, token = tokens[i];
                        pray('no missing close tags', token);
                        // close tags
                        if (token.slice(0, 2) === '</') {
                            nesting -= 1;
                        }
                        // non-self-closing open tags
                        else if (token.charAt(0) === '<' && token.slice(-2) !== '/>') {
                            nesting += 1;
                        }
                    } while (nesting > 0);
                }
            }
            return tokens.join('').replace(/>&(\d+)/g, function ($0, $1) {
                return ' mathquill-block-id=' + blocks[$1].id + '>' + blocks[$1].join('html');
            
            });
        };

        // methods to export a string representation of the math tree
        _.latex = function () {
            return this.foldChildren(this.ctrlSeq, function (latex, child) {
                return latex + '{' + (child.latex() || ' ') + '}';
            });
        };
        _.textTemplate = [''];
        _.text = function () {
            var cmd = this,
                i = 0;
            return cmd.foldChildren(cmd.textTemplate[i], function (text, child) {
                i += 1;
                var child_text = child.text();
                if (text && cmd.textTemplate[i] === '(' && child_text[0] === '(' && child_text.slice(-1) === ')') return text + child_text.slice(1, -1) + cmd.textTemplate[i];
                return text + child.text() + (cmd.textTemplate[i] || '');
            });
        };
    });

    /**
     * Lightweight command without blocks or children.
     */
    var Symbol = P(MathCommand, function (_, _super) {
        _.init = function (ctrlSeq, html, text) {
            if (!text) text = ctrlSeq && ctrlSeq.length > 1 ? ctrlSeq.slice(1) : ctrlSeq;

            _super.init.call(this, ctrlSeq, html, [text]);
        };

        _.parser = function () {
            return Parser.succeed(this);
        };
        _.numBlocks = function () {
            return 0;
        };

        _.replaces = function (replacedFragment) {
            replacedFragment.remove();
        };
        _.createBlocks = noop;
        _.latex = function () {
            return this.ctrlSeq;
        };
        _.text = function () {
            return this.textTemplate;
        };
        _.placeCursor = noop;
        _.isEmpty = function () {
            return true;
        };
    });

    /**
     * Children and parent of MathCommand's. Basically partitions all the
     * symbols and operators that descend (in the Math DOM tree) from
     * ancestor operators.
     */
    var MathBlock = P(MathElement, function (_) {
        _.join = function (methodName) {
            return this.foldChildren('', function (fold, child) {
                return fold + child[methodName]();
            });
        };
        _.latex = function () {
            return this.join('latex');
        };
        _.text = function () {
            return this.ends[L] === this.ends[R] ? this.ends[L].text() : '(' + this.join('text') + ')';
        };
        _.isEmpty = function () {
            return this.ends[L] === 0 && this.ends[R] === 0;
        };
        _.write = function (cursor, ch, replacedFragment) {
            var cmd;
            if (ch.match(/^[a-eg-zA-Z]$/)) //exclude f because want florin
            cmd = Variable(ch);
            else if (cmd = CharCmds[ch] || LatexCmds[ch]) cmd = cmd(ch);
            else cmd = VanillaSymbol(ch);

            if (replacedFragment) cmd.replaces(replacedFragment);

            cmd.createLeftOf(cursor);
        };
        _.focus = function () {
            this.jQ.addClass('hasCursor');
            this.jQ.removeClass('empty');

            return this;
        };
        _.blur = function () {
            this.jQ.removeClass('hasCursor');
            if (this.isEmpty()) this.jQ.addClass('empty');

            return this;
        };
    });

    /**
     * Math tree fragment base class.
     * Some math-tree-specific extensions to Fragment.
     */
    var MathFragment = P(Fragment, function (_, _super) {
        _.init = function (leftEnd, rightEnd) {
            // just select one thing if only one argument
            _super.init.call(this, leftEnd, rightEnd || leftEnd);
            this.jQ = this.fold($(), function (jQ, child) {
                return child.jQ.add(jQ);
            });
        };
        _.latex = function () {
            return this.fold('', function (latex, el) {
                return latex + el.latex();
            });
        };
        _.remove = function () {
            this.jQ.remove();

            this.each(function (el) {
                el.postOrder(function (desc) {
                    delete MathElement[desc.id];
                });
            });

            return this.disown();
        };
    });
    /*********************************************
     * Root math elements with event delegation.
     ********************************************/

    function createRoot(jQ, root, textbox, editable) {
        var contents = jQ.contents().detach();

        if (!textbox) {
            jQ.addClass('mathquill-rendered-math');
        }

        root.jQ = jQ.attr(mqBlockId, root.id);
        root.revert = function () {
            jQ.empty().unbind('.mathquill').removeClass('mathquill-rendered-math mathquill-editable mathquill-textbox').append(contents);
        };

        var cursor = root.cursor = Cursor(root);

        root.renderLatex(contents.text());

        //textarea stuff
        var textareaSpan = root.textarea = $('<span class="textarea"><textarea></textarea></span>'),
            textarea = textareaSpan.children();

        /******
         * TODO [Han]: Document this
         */
        var textareaSelectionTimeout;
        root.selectionChanged = function () {
            if (textareaSelectionTimeout === undefined) {
                textareaSelectionTimeout = setTimeout(setTextareaSelection);
            }
            forceIERedraw(jQ[0]);
        };

        function setTextareaSelection() {
            textareaSelectionTimeout = undefined;
            var latex = cursor.selection ? '$' + cursor.selection.latex() + '$' : '';
            textareaManager.select(latex);
        }

        //prevent native selection except textarea
        jQ.bind('selectstart.mathquill', function (e) {
            if (e.target !== textarea[0]) e.preventDefault();
            e.stopPropagation();
        });

        //drag-to-select event handling
        var anticursor, blink = cursor.blink;
        jQ.bind('mousedown.mathquill', function (e) {
            function mousemove(e) {
                cursor.seek($(e.target), e.pageX, e.pageY);

                if (cursor[L] !== anticursor[L] || cursor.parent !== anticursor.parent) {
                    cursor.selectFrom(anticursor);
                }

                return false;
            }

            // docmousemove is attached to the document, so that
            // selection still works when the mouse leaves the window.


            function docmousemove(e) {
                // [Han]: i delete the target because of the way seek works.
                // it will not move the mouse to the target, but will instead
                // just seek those X and Y coordinates.  If there is a target,
                // it will try to move the cursor to document, which will not work.
                // cursor.seek needs to be refactored.
                delete e.target;

                return mousemove(e);
            }

            function mouseup(e) {
                anticursor = undefined;
                cursor.blink = blink;
                if (!cursor.selection) {
                    if (editable) {
                        cursor.show();
                    } else {
                        textareaSpan.detach();
                    }
                }

                // delete the mouse handlers now that we're not dragging anymore
                jQ.unbind('mousemove', mousemove);
                $(e.target.ownerDocument).unbind('mousemove', docmousemove).unbind('mouseup', mouseup);
            }

            setTimeout(function () {
                textarea.focus();
            });
            // preventDefault won't prevent focus on mousedown in IE<9
            // that means immediately after this mousedown, whatever was
            // mousedown-ed will receive focus
            // http://bugs.jquery.com/ticket/10345
            cursor.blink = noop;
            cursor.seek($(e.target), e.pageX, e.pageY);

            anticursor = Point(cursor.parent, cursor[L], cursor[R]);

            if (!editable) jQ.prepend(textareaSpan);

            jQ.mousemove(mousemove);
            $(e.target.ownerDocument).mousemove(docmousemove).mouseup(mouseup);

            return false;
        });

        if (!editable) {
            var textareaManager = manageTextarea(textarea, {
                container: jQ
            });
            jQ.bind('cut paste', false).bind('copy', setTextareaSelection).prepend('<span class="selectable">$' + root.latex() + '$</span>');
            textarea.blur(function () {
                cursor.clearSelection();
                setTimeout(detach); //detaching during blur explodes in WebKit
            });

            textarea.detach(function () {
                textareaSpan.detach();
            });
/*function detach() {
                textareaSpan.detach();
            }*/
            return;
        }

        var textareaManager = manageTextarea(textarea, {
            container: jQ,
            key: function (key, evt) {
                cursor.parent.bubble('onKey', key, evt);
            },
            text: function (text) {
                cursor.parent.bubble('onText', text);
            },
            cut: function (e) {
                if (cursor.selection) {
                    setTimeout(function () {
                        cursor.prepareEdit();
                        cursor.parent.bubble('redraw');
                    });
                }

                e.stopPropagation();
            },
            paste: function (text) {
                // FIXME HACK the parser in RootTextBlock needs to be moved to
                // Cursor::writeLatex or something so this'll work with
                // MathQuill textboxes
                if (text.slice(0, 1) === '$' && text.slice(-1) === '$') {
                    text = text.slice(1, -1);
                } else {
                    text = '\\text{' + text + '}';
                }

                cursor.writeLatex(text).show();
            }
        });

        jQ.prepend(textareaSpan);

        //root CSS classes
        jQ.addClass('mathquill-editable');
        if (textbox) jQ.addClass('mathquill-textbox');

        //focus and blur handling
        textarea.focus(function (e) {
            if (!cursor.parent) cursor.insAtRightEnd(root);
            cursor.parent.jQ.addClass('hasCursor');
            if (cursor.selection) {
                cursor.selection.jQ.removeClass('blur');
                setTimeout(root.selectionChanged); //re-select textarea contents after tabbing away and back
            } else cursor.show();
            e.stopPropagation();
        }).blur(function (e) {
            cursor.hide().parent.blur();
            if (cursor.selection) cursor.selection.jQ.addClass('blur');
            e.stopPropagation();
        });

        jQ.bind('focus.mathquill blur.mathquill', function (e) {
            textarea.trigger(e);
        }).blur();
    }

    var RootMathBlock = P(MathBlock, function (_, _super) {
        _.latex = function () {

            return _super.latex.call(this).replace(/(\\[a-z]+) (?![a-z])/ig, '$1');
        };
        _.text = function () {
            return this.foldChildren('', function (text, child) {
                return text + child.text();
            });
        };
        _.renderLatex = function (latex) {
            var jQ = this.jQ;

            jQ.children().slice(1).remove();
            this.ends[L] = this.ends[R] = 0;

            delete this.cursor.selection;
            this.cursor.insAtRightEnd(this).writeLatex(latex);
        };
        _.onKey = function (key, e) {
            switch (key) {
            case 'Ctrl-Shift-Backspace':
            case 'Ctrl-Backspace':
                while (this.cursor[L] || this.cursor.selection) {
                    this.cursor.backspace();
                }
                break;

            case 'Shift-Backspace':
            case 'Backspace':
                this.cursor.backspace();
                break;

                // Tab or Esc -> go one block right if it exists, else escape right.
            case 'Esc':
            case 'Tab':
            case 'Spacebar':
                var parent = this.cursor.parent;
                // cursor is in root editable, continue default
                if (parent === this.cursor.root) {
                    if (key === 'Spacebar') e.preventDefault();
                    return;
                }

                this.cursor.prepareMove();
                if (parent[R]) {
                    // go one block right
                    this.cursor.insAtLeftEnd(parent[R]);
                } else {
                    // get out of the block
                    this.cursor.insRightOf(parent.parent);
                }
                break;

                // Shift-Tab -> go one block left if it exists, else escape left.
            case 'Shift-Tab':
            case 'Shift-Esc':
            case 'Shift-Spacebar':
                var parent = this.cursor.parent;
                //cursor is in root editable, continue default
                if (parent === this.cursor.root) {
                    if (key === 'Shift-Spacebar') e.preventDefault();
                    return;
                }

                this.cursor.prepareMove();
                if (parent[L]) {
                    // go one block left
                    this.cursor.insAtRightEnd(parent[L]);
                } else {
                    //get out of the block
                    this.cursor.insLeftOf(parent.parent);
                }
                break;

                // Prevent newlines from showing up
            case 'Enter':
                var parent = this.cursor.parent;
                // cursor is in root editable, continue default
                if (parent === this.cursor.root) {
                    if (key === 'Enter') this.cursor.write("\\\\");

                    return;
                }
                break;

                ;


                // End -> move to the end of the current block.
            case 'End':
                this.cursor.prepareMove().insAtRightEnd(this.cursor.parent);
                break;

                // Ctrl-End -> move all the way to the end of the root block.
            case 'Ctrl-End':
                this.cursor.prepareMove().insAtRightEnd(this);
                break;

                // Shift-End -> select to the end of the current block.
            case 'Shift-End':
                while (this.cursor[R]) {
                    this.cursor.selectRight();
                }
                break;

                // Ctrl-Shift-End -> select to the end of the root block.
            case 'Ctrl-Shift-End':
                while (this.cursor[R] || this.cursor.parent !== this) {
                    this.cursor.selectRight();
                }
                break;

                // Home -> move to the start of the root block or the current block.
            case 'Home':
                this.cursor.prepareMove().insAtLeftEnd(this.cursor.parent);
                break;

                // Ctrl-Home -> move to the start of the current block.
            case 'Ctrl-Home':
                this.cursor.prepareMove().insAtLeftEnd(this);
                break;

                // Shift-Home -> select to the start of the current block.
            case 'Shift-Home':
                while (this.cursor[L]) {
                    this.cursor.selectLeft();
                }
                break;

                // Ctrl-Shift-Home -> move to the start of the root block.
            case 'Ctrl-Shift-Home':
                while (this.cursor[L] || this.cursor.parent !== this) {
                    this.cursor.selectLeft();
                }
                break;

            case 'Left':
                this.cursor.moveLeft();
                break;
            case 'Shift-Left':
                this.cursor.selectLeft();
                break;
            case 'Ctrl-Left':
                break;

            case 'Right':
                this.cursor.moveRight();
                break;
            case 'Shift-Right':
                this.cursor.selectRight();
                break;
            case 'Ctrl-Right':
                break;

            case 'Up':
                this.cursor.moveUp();
                break;
            case 'Down':
                this.cursor.moveDown();
                break;

            case 'Shift-Up':
                if (this.cursor[L]) {
                    while (this.cursor[L]) this.cursor.selectLeft();
                } else {
                    this.cursor.selectLeft();
                }

            case 'Shift-Down':
                if (this.cursor[R]) {
                    while (this.cursor[R]) this.cursor.selectRight();
                } else {
                    this.cursor.selectRight();
                }

            case 'Ctrl-Up':
                break;
            case 'Ctrl-Down':
                break;

            case 'Ctrl-Shift-Del':
            case 'Ctrl-Del':
                while (this.cursor[R] || this.cursor.selection) {
                    this.cursor.deleteForward();
                }
                break;

            case 'Shift-Del':
            case 'Del':
                this.cursor.deleteForward();
                break;

            case 'Meta-A':
            case 'Ctrl-A':
                //so not stopPropagation'd at RootMathCommand
                if (this !== this.cursor.root) return;

                this.cursor.prepareMove().insAtRightEnd(this);
                while (this.cursor[L]) this.cursor.selectLeft();
                break;

            default:
                return false;
            }
            e.preventDefault();
            return false;
        };
        _.onText = function (ch) {
            this.cursor.write(ch);
            return false;
        };
    });

    var RootMathCommand = P(MathCommand, function (_, _super) {
        _.init = function (cursor) {
            _super.init.call(this, '$');
            this.cursor = cursor;
        };
        _.htmlTemplate = '<span class="mathquill-rendered-math">&0</span>';
        _.createBlocks = function () {
            this.ends[L] = this.ends[R] = RootMathBlock();

            this.blocks = [this.ends[L]];

            this.ends[L].parent = this;

            this.ends[L].cursor = this.cursor;
            this.ends[L].write = function (cursor, ch, replacedFragment) {
                if (ch !== '$') MathBlock.prototype.write.call(this, cursor, ch, replacedFragment);
                else if (this.isEmpty()) {
                    cursor.insRightOf(this.parent).backspace().show();
                    VanillaSymbol('\\$', '$').createLeftOf(cursor);
                } else if (!cursor[R]) cursor.insRightOf(this.parent);
                else if (!cursor[L]) cursor.insLeftOf(this.parent);
                else MathBlock.prototype.write.call(this, cursor, ch, replacedFragment);
            };
        };
        _.latex = function () {
            return '$' + this.ends[L].latex() + '$';
        };
    });

    var RootTextBlock = P(MathBlock, function (_) {
        _.renderLatex = function (latex) {
            var self = this;
            var cursor = self.cursor;
            self.jQ.children().slice(1).remove();
            self.ends[L] = self.ends[R] = 0;
            delete cursor.selection;
            cursor.show().insAtRightEnd(self);

            var regex = Parser.regex;
            var string = Parser.string;
            var eof = Parser.eof;
            var all = Parser.all;

            // Parser RootMathCommand
            var mathMode = string('$').then(latexMathParser)
            // because TeX is insane, math mode doesn't necessarily
            // have to end.  So we allow for the case that math mode
            // continues to the end of the stream.
            .skip(string('$').or(eof)).map(function (block) {
                // HACK FIXME: this shouldn't have to have access to cursor
                var rootMathCommand = RootMathCommand(cursor);

                rootMathCommand.createBlocks();
                var rootMathBlock = rootMathCommand.ends[L];
                block.children().adopt(rootMathBlock, 0, 0);

                return rootMathCommand;
            });

            var escapedDollar = string('\\$').result('$');
            var textChar = escapedDollar.or(regex(/^[^$]/)).map(VanillaSymbol);
            var latexText = mathMode.or(textChar).many();
            var commands = latexText.skip(eof).or(all.result(false)).parse(latex);

            if (commands) {
                for (var i = 0; i < commands.length; i += 1) {
                    commands[i].adopt(self, self.ends[R], 0);
                }

                var html = self.join('html');
                MathElement.jQize(html).appendTo(self.jQ);

                this.finalizeInsert();
            }
        };
        _.onKey = function (key) {
            if (key === 'Spacebar' || key === 'Shift-Spacebar') return;
            RootMathBlock.prototype.onKey.apply(this, arguments);
        };
        _.onText = RootMathBlock.prototype.onText;
        _.write = function (cursor, ch, replacedFragment) {
            if (replacedFragment) replacedFragment.remove();
            if (ch === '$') RootMathCommand(cursor).createLeftOf(cursor);
            else {
                var html;
                if (ch === '<') html = '&lt;';
                else if (ch === '>') html = '&gt;';
                VanillaSymbol(ch, html).createLeftOf(cursor);
            }
        };
    });
    /***************************
     * Commands and Operators.
     **************************/

    var CharCmds = {},
        LatexCmds = {}; //single character commands, LaTeX commands
    var scale, // = function(jQ, x, y) { ... }
    //will use a CSS 2D transform to scale the jQuery-wrapped HTML elements,
    //or the filter matrix transform fallback for IE 5.5-8, or gracefully degrade to
    //increasing the fontSize to match the vertical Y scaling factor.
    //ideas from http://github.com/louisremi/jquery.transform.js
    //see also http://msdn.microsoft.com/en-us/library/ms533014(v=vs.85).aspx
    forceIERedraw = noop,
        div = document.createElement('div'),
        div_style = div.style,
        transformPropNames = {
            transform: 1,
            WebkitTransform: 1,
            MozTransform: 1,
            OTransform: 1,
            msTransform: 1
        },
        transformPropName;

    for (var prop in transformPropNames) {
        if (prop in div_style) {
            transformPropName = prop;
            break;
        }
    }

    if (transformPropName) {
        scale = function (jQ, x, y) {
            jQ.css(transformPropName, 'scale(' + x + ',' + y + ')');
        };
    } else if ('filter' in div_style) { //IE 6, 7, & 8 fallback, see https://github.com/laughinghan/mathquill/wiki/Transforms
        forceIERedraw = function (el) {
            el.className = el.className;
        };
        scale = function (jQ, x, y) { //NOTE: assumes y > x
            x /= (1 + (y - 1) / 2);
            jQ.css('fontSize', y + 'em');
            if (!jQ.hasClass('matrixed-container')) {
                jQ.addClass('matrixed-container').wrapInner('<span class="matrixed"></span>');
            }
            var innerjQ = jQ.children().css('filter', 'progid:DXImageTransform.Microsoft' + '.Matrix(M11=' + x + ",SizingMethod='auto expand')");

            function calculateMarginRight() {
                jQ.css('marginRight', (innerjQ.width() - 1) * (x - 1) / x + 'px');
            }
            calculateMarginRight();
            var intervalId = setInterval(calculateMarginRight);
            $(window).load(function () {
                clearTimeout(intervalId);
                calculateMarginRight();
            });
        };
    } else {
        scale = function (jQ, x, y) {
            jQ.css('fontSize', y + 'em');
        };
    }

    var Style = P(MathCommand, function (_, _super) {
        _.init = function (ctrlSeq, tagName, attrs) {
            _super.init.call(this, ctrlSeq, '<' + tagName + ' ' + attrs + '>&0</' + tagName + '>');
        };
    });
	var Style2 = P(MathCommand, function (_, _super) {
        _.init = function (ctrlSeq, tagName, attrs) {
            _super.init.call(this, ctrlSeq, '<' + tagName + ' ' + attrs + '>&0</' + tagName + '>');
        };
    });
	LatexCmds.block = bind(Style2, '', 'span', 'class=" "');
    //fonts
    LatexCmds.mathrm = bind(Style, '\\mathrm', 'span', 'class="roman font "');
    LatexCmds.mathit = bind(Style, '\\mathit', 'i', 'class="font"');
    LatexCmds.mathbf = bind(Style, '\\mathbf', 'b', 'class="font"');
    LatexCmds.mathsf = bind(Style, '\\mathsf', 'span', 'class="sans-serif font"');
    LatexCmds.mathtt = bind(Style, '\\mathtt', 'span', 'class="monospace font"');
    //text-decoration
    LatexCmds.underline = bind(Style, '\\underline', 'span', 'class="non-leaf underline"');
    LatexCmds.overline = LatexCmds.bar = bind(Style, '\\overline', 'span', 'class="non-leaf overline"');

    var SupSub = P(MathCommand, function (_, _super) {
        _.init = function (ctrlSeq, tag, text) {
            _super.init.call(this, ctrlSeq, '<' + tag + ' class="non-leaf">&0</' + tag + '>', [text]);
        };
        _.finalizeTree = function () {
            //TODO: use inheritance
            pray('SupSub is only _ and ^', this.ctrlSeq === '^' || this.ctrlSeq === '_');

            if (this.ctrlSeq === '_') {
                this.down = this.ends[L];
                this.ends[L].up = insLeftOfMeUnlessAtEnd;
            } else {
                this.up = this.ends[L];
                this.ends[L].down = insLeftOfMeUnlessAtEnd;
            }

            function insLeftOfMeUnlessAtEnd(cursor) {
                // cursor.insLeftOf(cmd), unless cursor at the end of block, and every
                // ancestor cmd is at the end of every ancestor block
                var cmd = this.parent,
                    ancestorCmd = cursor;
                do {
                    if (ancestorCmd[R]) {
                        cursor.insLeftOf(cmd);
                        return false;
                    }
                    ancestorCmd = ancestorCmd.parent.parent;
                } while (ancestorCmd !== cmd);
                cursor.insRightOf(cmd);
                return false;
            }
        };
        _.latex = function () {
            var latex = this.ends[L].latex();
            if (latex.length === 1) return this.ctrlSeq + latex;
            else return this.ctrlSeq + '{' + (latex || ' ') + '}';
        };
        _.redraw = function () {
            if (this[L]) this[L].respace();
            //SupSub::respace recursively calls respace on all the following SupSubs
            //so if leftward is a SupSub, no need to call respace on this or following nodes
            if (!(this[L] instanceof SupSub)) {
                this.respace();
                //and if rightward is a SupSub, then this.respace() will have already called
                //this[R].respace()
                if (this[R] && !(this[R] instanceof SupSub)) this[R].respace();
            }
        };
        _.respace = function () {
            if (
            this[L].ctrlSeq === '\\int\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\int\\limits ') || this[L].ctrlSeq === '\\oint\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\oint\\limits ') || this[L].ctrlSeq === '\\iint\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\iint\\limits ') || this[L].ctrlSeq === '\\iiint\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\iiint\\limits ') || this[L].ctrlSeq === '\\iiiint\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\iiiint\\limits ') || this[L].ctrlSeq === '\\sum\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\sum\\limits ') || this[L].ctrlSeq === '\\lim\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\lim\\limits ')
            || this[L].ctrlSeq === '\\prod\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\prod\\limits ')
            || this[L].ctrlSeq === '\\coprod\\limits ' || (
            this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && this[L][L] && this[L][L].ctrlSeq === '\\coprod\\limits ')
            ) {
                if (!this.limit) {
                    this.limit = true;
                    this.jQ.addClass('limit');
                }
            } else {
                if (this.limit) {
                    this.limit = false;
                    this.jQ.removeClass('limit');
                }
            }
            //var sup=this[L][L][R];
            if (this[L] !== 0) {
                var keep2 = this[L].ctrlSeq;
            }
            this.respaced = this[L] instanceof SupSub && this[L].ctrlSeq != this.ctrlSeq && !this[L].respaced;
            if (this.respaced) {
                var fontSize = +this.jQ.css('fontSize').slice(0, -2),
                    leftWidth = this[L].jQ.outerWidth(),
                    thisWidth = this.jQ.outerWidth();

                if (this[L][L] !== 0) {
                    var keep = this[L][L].ctrlSeq;
                }

                if (this[L][L] !== 0) {
                    var parentWidth = this[L][L].jQ.outerWidth();
                    parentWidth = parentWidth / 3;
                }
                if (this[L][L] !== 0 && this[L][L][R] !== 0) {
                    var topWidth = this[L][L][R].jQ.outerWidth();
                }
                if (typeof keep !== 'undefined') {
                    //alert(leftWidth  );
                    if (keep === '\\int\\limits ' || keep === '\\iint\\limits ' || keep === '\\iiint\\limits ' || keep === '\\iiiint\\limits ') {

                        //bottom
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.99 : 0) - parentWidth / fontSize - (thisWidth / 2 / 10 / 10) + 'em',
                            marginRight: -(.1 + thisWidth / 2 / 10) + 'em'

                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                        //top
                        this[L][L][R].jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.49 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(-.5 + topWidth / 2 / 10) + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    } else if (keep === '\\oint\\limits ') {
                        //bottom
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -1 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(.1 + thisWidth / 2 / 10) + 'em'

                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                        //top
                        this[L][L][R].jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.49 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(-.5 + topWidth / 2 / 10) + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    } else if (keep === '\\sum\\limits ') {
                        //bottom
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.99 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(.1 + thisWidth / 2 / 10) + 'em'

                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                        //top
                        this[L][L][R].jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.49 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(-.5 + topWidth / 2 / 10) + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    } else if (keep === '\\prod\\limits ') {
                        //bottom
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.99 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(.1 + thisWidth / 2 / 10) + 'em'

                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                        //top
                        this[L][L][R].jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.39 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(-.5 + topWidth / 2 / 10) + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    }else if (keep === '\\coprod\\limits ') {
                        //bottom
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.99 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(.1 + thisWidth / 2 / 10) + 'em'

                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                        //top
                        this[L][L][R].jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.39 : 0) - parentWidth / fontSize + 'em',
                            marginRight: -(-.5 + topWidth / 2 / 10) + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    }
                    else {
                        this.jQ.css({
                            left: (this.limit && this.ctrlSeq === '_' ? -.25 : 0) - leftWidth / fontSize + 'em',
                            marginRight: .1 - min(thisWidth, leftWidth) / fontSize + 'em'
                            //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                        });
                    }
                } else {
                    this.jQ.css({
                        left: (this.limit && this.ctrlSeq === '_' ? -.25 : 0) - leftWidth / fontSize + 'em',
                        marginRight: .1 - min(thisWidth, leftWidth) / fontSize + 'em'
                        //1px extra so it doesn't wrap in retarded browsers (Firefox 2, I think)
                    });
                }
            } else if (this.limit && this.ctrlSeq === '_') {
                if (keep2 === '\\lim\\limits ') {
                    var fontSize = +this.jQ.css('fontSize').slice(0, -2),
                        parentWidth = this[L].jQ.outerWidth() / 3,
                        thisWidth = this.jQ.outerWidth();
                    this.jQ.css({
                        left: (this.limit && this.ctrlSeq === '_' ? -.49 : 0) - parentWidth / fontSize - (thisWidth / 2 / 10 / 5) + 'em',
                        marginRight: .6 - (thisWidth / 2 / 10) + 'em'
                    });
                } else {
                    this.jQ.css({
                        left: '-.25em',
                        marginRight: ''
                    });
                }
            } else {
                this.jQ.css({
                    left: '',
                    marginRight: ''
                });
            }

            if (this[R] instanceof SupSub) this[R].respace();

            return this;
        };
    });

    LatexCmds.subscript = LatexCmds._ = bind(SupSub, '_', 'sub', '_');

    LatexCmds.superscript = LatexCmds.supscript = LatexCmds['^'] = bind(SupSub, '^', 'sup', '**');
    var Fraction = LatexCmds.frac = LatexCmds.dfrac = LatexCmds.cfrac = LatexCmds.fraction = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\frac';
        _.htmlTemplate = '<span class="fraction non-leaf">' + '<span class="numerator">&0</span>' + '<span class="denominator ">&1</span>' + '<span style="display:inline-block;width:0">&nbsp;</span>' + '</span>';
        _.textTemplate = ['(', '/', ')'];
        _.finalizeTree = function () {
            this.up = this.ends[R].up = this.ends[L];
            this.down = this.ends[L].down = this.ends[R];
        };
    });
    //clone fraction-> 
    var FractionArrowLeft = LatexCmds.xleftarrow = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\xleftarrow';
        _.htmlTemplate = '<span class="fraction non-leaf">' + '<span class="xleftover">&0</span>' + '<span class="lefttriangel"></span> ' + '<span class="xleftbelow ">&1</span>' + '<span style="display:inline-block;width:0">&nbsp;</span>' + '</span>';
        _.textTemplate = ['xleftarrow[', '](', ')'];
        // _.textTemplate = ['(', '/', ')'];
        _.parser = function () {
            return latexMathParser.optBlock.then(function (optBlock) {
                return latexMathParser.block.map(function (block) {
                    var nthroot = FractionArrowLeft();
                    nthroot.blocks = [block, optBlock];
                    optBlock.adopt(nthroot, 0, 0);
                    block.adopt(nthroot, optBlock, 0);
                    return nthroot;
                });
            }).or(_super.parser.call(this));
        };
        _.finalizeTree = function () {
            this.up = this.ends[R].up = this.ends[L];
            this.down = this.ends[L].down = this.ends[R];
        };
        _.latex = function () {
            return '\\xleftarrow[' + this.ends[R].latex() + ']{' + this.ends[L].latex() + '}';
        };
    });
    //end clone fraction
    //clone fraction-> 
    var FractionArrowRight = LatexCmds.xrightarrow = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\xrightarrow';
        _.htmlTemplate = '<span class="fraction non-leaf">' + '<span class="xrightover">&0</span>' + '<span class="righttriangel"></span> ' + '<span class="xrightbelow ">&1</span>' + '<span style="display:inline-block;width:0">&nbsp;</span>' + '</span>';
        _.textTemplate = ['xrightarrow[', '](', ')'];
        // _.textTemplate = ['(', '/', ')'];
        _.parser = function () {
            return latexMathParser.optBlock.then(function (optBlock) {
                return latexMathParser.block.map(function (block) {
                    var nthroot = FractionArrowRight();
                    nthroot.blocks = [block, optBlock];
                    optBlock.adopt(nthroot, 0, 0);
                    block.adopt(nthroot, optBlock, 0);
                    return nthroot;
                });
            }).or(_super.parser.call(this));
        };
        _.finalizeTree = function () {
            this.up = this.ends[R].up = this.ends[L];
            this.down = this.ends[L].down = this.ends[R];
        };
        _.latex = function () {
            return '\\xrightarrow[' + this.ends[R].latex() + ']{' + this.ends[L].latex() + '}';
        };
    });
    //end clone fraction
    var LiveFraction = LatexCmds.over = CharCmds['/']= P(Fraction, function (_, _super) {
        _.createLeftOf = function (cursor) {
            if (!this.replacedFragment) {
                var leftward = cursor[L];
                while (leftward && !(
                leftward instanceof BinaryOperator || leftward instanceof TextBlock || leftward instanceof BigSymbol || ',;:'.split('').indexOf(leftward.ctrlSeq) > -1) //lookbehind for operator
                )
                leftward = leftward[L];

                if (leftward instanceof BigSymbol && leftward[R] instanceof SupSub) {
                    leftward = leftward[R];
                    if (leftward[R] instanceof SupSub && leftward[R].ctrlSeq != leftward.ctrlSeq) leftward = leftward[R];
                }

                if (leftward !== cursor[L]) {
                    this.replaces(MathFragment(leftward[R] || cursor.parent.ends[L], cursor[L]));
                    cursor[L] = leftward;
                }
            }
            _super.createLeftOf.call(this, cursor);
        };
    });

    var SquareRoot = LatexCmds.sqrt = LatexCmds['√'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\sqrt';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="scaled sqrt-prefix">&radic;</span>' + '<span class="non-leaf sqrt-stem">&0</span>' + '</span>';
        _.textTemplate = ['sqrt(', ')'];
        _.parser = function () {
            return latexMathParser.optBlock.then(function (optBlock) {
                return latexMathParser.block.map(function (block) {
                    var nthroot = NthRoot();
                    nthroot.blocks = [optBlock, block];
                    optBlock.adopt(nthroot, 0, 0);
                    block.adopt(nthroot, optBlock, 0);
                    return nthroot;
                });
            }).or(_super.parser.call(this));
        };
        _.redraw = function () {
            var block = this.ends[R].jQ;
            scale(block.prev(), 1, block.innerHeight() / +block.css('fontSize').slice(0, -2) - .1);
        };
    });
    var Underrightarrow = LatexCmds.underrightarrow = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\underrightarrow';
        _.htmlTemplate =
            '<span class="non-leaf">'
          + '<span class="underright-stem">&0</span>'
          + '<span class="scaled underright-prefix">&rarr;</span>'
          + '</span>'
        ;
        _.textTemplate = ['underright(', ')'];
        _.redraw = function () {
            var blockjQ = this.ends[R].jQ;
            var width = blockjQ.outerWidth() / +blockjQ.css('fontSize').slice(0, -2);
            scale(blockjQ.next(), width*0.7, 1);
        };
    });
        var Overrightarrow = LatexCmds.overrightarrow = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\overrightarrow';
        _.htmlTemplate =
            '<span class="non-leaf">'
          + '<span class="scaled overright-prefix">&rarr;</span>'
          + '<span class="overright-stem">&0</span>'
          + '</span>'
        ;
        _.textTemplate = ['overright(', ')'];
        _.redraw = function () {
            var blockjQ = this.ends[R].jQ;
            var width = blockjQ.outerWidth() / +blockjQ.css('fontSize').slice(0, -2);
            scale(blockjQ.prev(), width*0.7, 1);
        };
    });
    var Vec = LatexCmds.vec = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\vec';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="vector-prefix">&rarr;</span>' + '<span class="vector-stem">&0</span>' + '</span>';
        _.textTemplate = ['vec(', ')'];
    });

    var Hat = LatexCmds.hat = LatexCmds['hat'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\hat';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="hat-prefix">&#94;</span>' + '<span class="vector-stem">&0</span>' + '</span>';
        _.textTemplate = ['hat{', '}'];
    });
    var WideHat = LatexCmds.widehat = LatexCmds['widehat'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\widehat';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="widehat-prefix">&#94;</span>' + '<span class="vector-stem">&0</span>' + '</span>';
        _.textTemplate = ['widehat{', '}'];
    });

    var Tilde = LatexCmds.tilde = LatexCmds['tilde'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\tilde';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="tilde-prefix">&#126;</span>' + '<span class="vector-stem">&0</span>' + '</span>';
        _.textTemplate = ['tilde{', '}'];
    });

    var WideTilde = LatexCmds.widetilde = LatexCmds['widetilde'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\widetilde';
        _.htmlTemplate = '<span class="non-leaf">' + '<span class="widetilde-prefix">&#126;</span>' + '<span class="vector-stem">&0</span>' + '</span>';
        _.textTemplate = ['widetilde{', '}'];
    });
    //add cases
    var CasesSize = null;
    var Cases = LatexCmds.cases = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\cases';
        _.htmlTemplate = '';
        _.latex = function () {
            var children = this.foldChildren([], function (latex, child) {
                latex.push(child.latex());
                return latex;
            });
            var string = '\\begin{cases}';
            
            var e=this.blocks.length;
            var t=this.jQ[0].rows.length;
            var columns=e/t;
           
            for (var i = 0; i < children.length; i++) {
                if (i % columns == 0 && i != 0) {
                    string += '\\\\';
                }
                string += children[i];
                // Don't append an ampersand at the end of the row
                if ((i + 1) % columns != 0) {
                    string += '&';
                }
            }
            string += '\\end{cases}';
            return string;
        };
        _.text = function () {
            return '[' + this.foldChildren([], function (text, child) {
                text.push(child.text());
                return text;
            }).join() + ']';
        };
        _.setSize = CasesSize = function (rows, columns) {
            _.columns = columns;
            var cases = '<table class="mtable non-leaf">';
            var count = 0;
            for (var row = 0; row < rows; row++) {
                cases += '<tr class="mtr non-leaf">';
                for (var col = 0; col < columns; col++) {
                    cases += '<td class="mtd"><span>&' + count + '</span></td>';
                    count++;
                }
                cases += '</tr>';
            }
            cases += '</table>';
            sizecases++;
            caseString+=cases;
            _.htmlTemplate = caseString;           
        };
        _.parser = function () {
            return Parser.succeed(this);
        };
    });
    // Pointer to the setSize() function in order to make it more easily accessible outside the closure
    // Pointer to the setSize() function in order to make it more easily accessible outside the closure
    var MatrixSize = null;
    var Matrix = LatexCmds.matrix = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\matrix';
        _.htmlTemplate = '';
        _.latex = function () {
            var children = this.foldChildren([], function (latex, child) {
                latex.push(child.latex());
                return latex;
            });
            var string = '\\begin{matrix}';
             
            var e=this.blocks.length;
            var t=this.jQ[0].rows.length;
            var columns=e/t;
             
            for (var i = 0; i < children.length; i++) {
                if (i % columns == 0 && i != 0) {
                    string += '\\\\';
                }
                string += children[i];
                // Don't append an ampersand at the end of the row
                if ((i + 1) % columns != 0) {
                    string += '&';
                }
            }
            string += '\\end{matrix}';
            return string;
        };
        _.text = function () {
            return '[' + this.foldChildren([], function (text, child) {
                text.push(child.text());
                return text;
            }).join() + ']';
        };
        _.setSize = MatrixSize = function (rows, columns) {
            _.columns = columns;
            var matrix = '<table class="mtable non-leaf">';
            var count = 0;
            for (var row = 0; row < rows; row++) {
                matrix += '<tr class="mtr non-leaf">';
                for (var col = 0; col < columns; col++) {
                    matrix += '<td class="mtd"><span>&' + count + '</span></td>';
                    count++;
                }
                matrix += '</tr>';
            }
            matrix += '</table>';
            sizematrix++;
            matrixString+=matrix;
            _.htmlTemplate = matrixString;
        };
        _.parser = function () {
            return Parser.succeed(this);
        };
    });
    var NthRoot = LatexCmds.nthroot = P(SquareRoot, function (_, _super) {
        _.htmlTemplate = '<sup class="nthroot non-leaf">&0</sup>' + '<span class="scaled">' + '<span class="sqrt-prefix scaled">&radic;</span>' + '<span class="sqrt-stem non-leaf">&1</span>' + '</span>';
        _.textTemplate = ['sqrt[', '](', ')'];
        _.latex = function () {
            return '\\sqrt[' + this.ends[L].latex() + ']{' + this.ends[R].latex() + '}';
        };
    });

    // Round/Square/Curly/Angle Brackets (aka Parens/Brackets/Braces)
    var Bracket = P(MathCommand, function (_, _super) {
        _.init = function (open, close, ctrlSeq, end) {
            _super.init.call(this, '\\left' + ctrlSeq, '<span class="non-leaf">' + '<span class="scaled paren">' 
                + open + '</span>' + '<span class="non-leaf">&0</span>' + '<span class="scaled paren">' 
                + close + '</span>' + '</span>', [open, close]);
            this.end = '\\right' + end;
        };
        _.jQadd = function () {
            _super.jQadd.apply(this, arguments);
            var jQ = this.jQ;
            this.bracketjQs = jQ.children(':first').add(jQ.children(':last'));
        };
        _.latex = function () {
            return this.ctrlSeq + this.ends[L].latex() + this.end;
        };
        _.redraw = function () {
            var blockjQ = this.ends[L].jQ;

            var height = blockjQ.outerHeight() / +blockjQ.css('fontSize').slice(0, -2);

            scale(this.bracketjQs, min(1 + .2 * (height - 1), 1.2), 1.05 * height);
        };
    });
    var RBracket = P(MathCommand, function (_, _super) {
        _.init = function (open, close, ctrlSeq, end) {
            _super.init.call(this, '\\left' + ctrlSeq, '<span class="non-leaf">' + '<span class="scaled paren none">' 
                + open + '</span>' + '<span class="non-leaf">&0</span>' + '<span class="scaled paren">' 
                + close + '</span>' + '</span>', [open, close]);
            this.end = '\\right' + end;
        };
        _.jQadd = function () {
            _super.jQadd.apply(this, arguments);
            var jQ = this.jQ;
            this.bracketjQs = jQ.children(':first').add(jQ.children(':last'));
        };
        _.latex = function () {
            return this.ctrlSeq + this.ends[L].latex() + this.end;
        };
        _.redraw = function () {
            var blockjQ = this.ends[L].jQ;

            var height = blockjQ.outerHeight() / +blockjQ.css('fontSize').slice(0, -2);

            scale(this.bracketjQs, min(1 + .2 * (height - 1), 1.2), 1.05 * height);
        };
    });
    var LBracket = P(MathCommand, function (_, _super) {
        _.init = function (open, close, ctrlSeq, end) {
            _super.init.call(this, '\\left' + ctrlSeq, '<span class="non-leaf">' + '<span class="scaled paren">' 
                + open + '</span>' + '<span class="non-leaf">&0</span>' + '<span class="scaled paren none">' 
                + close + '</span>' + '</span>', [open, close]);
            this.end = '\\right' + end;
        };
        _.jQadd = function () {
            _super.jQadd.apply(this, arguments);
            var jQ = this.jQ;
            this.bracketjQs = jQ.children(':first').add(jQ.children(':last'));
        };
        _.latex = function () {
            return this.ctrlSeq + this.ends[L].latex() + this.end;
        };
        _.redraw = function () {
            var blockjQ = this.ends[L].jQ;

            var height = blockjQ.outerHeight() / +blockjQ.css('fontSize').slice(0, -2);

            scale(this.bracketjQs, min(1 + .2 * (height - 1), 1.2), 1.05 * height);
        };
    });
    LatexCmds.left = P(MathCommand, function (_) {
        _.parser = function () {
            var regex = Parser.regex;
            var string = Parser.string;
            var succeed = Parser.succeed;
            var optWhitespace = Parser.optWhitespace;
            var open1;
            var block1;
            return optWhitespace.then(regex(/^(?:[([|\.]|\\\{)/)).then(function (open) {
                if (open.charAt(0) === '\\') open = open.slice(1);
                open1=open;
               

                return latexMathParser.map(function (block) {
                   block1=block;
                }).then(string('\\right')).skip(optWhitespace).then(regex(/^(?:[\])\.|]|\\\})/)).then(function (close) {
                    if(close==='\.'&& open1==='|'){
                        open1= "lpipe";
                    }
                    else if(open1==='\.'&& close==='|'){
                        open1= "rpipe";
                    }
                     var cmd = CharCmds[open1]();
                      cmd.blocks = [block1];
                      block1.adopt(cmd, 0, 0);
                    if (close.slice(-1) !== cmd.end.slice(-1)) {
                        return Parser.fail('open doesn\'t match close');
                    }

                    return succeed(cmd);
                });
            });
        };
    });

    LatexCmds.right = P(MathCommand, function (_) {
        _.parser = function () {
            return Parser.fail('unmatched \\right');
        };
    });

    LatexCmds.lbrace = CharCmds['{'] = bind(Bracket, '{', '}', '\\{', '\\}');
    LatexCmds.langle = LatexCmds.lang = bind(Bracket, '&lang;', '&rang;', '\\langle ', '\\rangle ');

    // Closing bracket matching opening bracket above
    var CloseBracket = P(Bracket, function (_, _super) {
        _.createLeftOf = function (cursor) {
            // if I'm at the end of my parent who is a matching open-paren,
            // and I am not replacing a selection fragment, don't create me,
            // just put cursor after my parent
            if (!cursor[R] && cursor.parent.parent && cursor.parent.parent.end === this.end && !this.replacedFragment) cursor.insRightOf(cursor.parent.parent);
            else _super.createLeftOf.call(this, cursor);
        };
        _.placeCursor = function (cursor) {
            this.ends[L].blur();
            cursor.insRightOf(this);
        };
    });

    LatexCmds.rbrace = CharCmds['}'] = bind(CloseBracket, '{', '}', '\\{', '\\}');
    LatexCmds.rangle = LatexCmds.rang = bind(CloseBracket, '&lang;', '&rang;', '\\langle ', '\\rangle ');

    var parenMixin = function (_, _super) {
            _.init = function (open, close) {
                _super.init.call(this, open, close, open, close);
            };
        };

    var Paren = P(Bracket, parenMixin);
    var LParen= P(LBracket,parenMixin);
    var RParen= P(RBracket,parenMixin);
    LatexCmds.lparen = CharCmds['('] = bind(Paren, '(', ')');
    LatexCmds.lbrack = LatexCmds.lbracket = CharCmds['['] = bind(Paren, '[', ']');

    var CloseParen = P(CloseBracket, parenMixin);

    LatexCmds.rparen = CharCmds[')'] = bind(CloseParen, '(', ')');
    LatexCmds.rbrack = LatexCmds.rbracket = CharCmds[']'] = bind(CloseParen, '[', ']');

    var Pipes =  CharCmds['|'] = P(Paren, function (_, _super) {
        _.init = function () {
            _super.init.call(this, '|', '|');
        };

        _.createLeftOf = CloseBracket.prototype.createLeftOf;
    });
    var LPipes = LatexCmds.lpipe=CharCmds['lpipe'] = P(LParen, function (_, _super) {
        _.init = function () {
            _super.init.call(this, '|', '.');
        };

        _.createLeftOf = CloseBracket.prototype.createLeftOf;
    });
    var RPipes = LatexCmds.rpipe=CharCmds['rpipe'] = P(RParen, function (_, _super) {
        _.init = function () {
            _super.init.call(this, '.', '|');
        };

        _.createLeftOf = CloseBracket.prototype.createLeftOf;
    });

    var TextBlock = CharCmds.$ = LatexCmds.text = LatexCmds.textnormal = LatexCmds.textrm = LatexCmds.textup = LatexCmds.textmd = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\text';
        _.htmlTemplate = '<span class="text">&0</span>';
        _.replaces = function (replacedText) {
            if (replacedText instanceof MathFragment) this.replacedText = replacedText.remove().jQ.text();
            else if (typeof replacedText === 'string') this.replacedText = replacedText;
        };
        _.textTemplate = ['"', '"'];
        _.parser = function () {
            var self = this;

            // TODO: correctly parse text mode
            var string = Parser.string;
            var regex = Parser.regex;
            var optWhitespace = Parser.optWhitespace;
            return optWhitespace.then(string('{')).then(regex(/^[^}]*/)).skip(string('}')).map(function (text) {
                self.createBlocks();
                var block = self.ends[L];
                for (var i = 0; i < text.length; i += 1) {
                    var ch = VanillaSymbol(text.charAt(i));
                    ch.adopt(block, block.ends[R], 0);
                }
                return self;
            });
        };
        _.createBlocks = function () {
            //FIXME: another possible Law of Demeter violation, but this seems much cleaner, like it was supposed to be done this way
            this.ends[L] = this.ends[R] = InnerTextBlock();

            this.blocks = [this.ends[L]];

            this.ends[L].parent = this;
        };
        _.finalizeInsert = function () {
            //FIXME HACK blur removes the TextBlock
            this.ends[L].blur = function () {
                delete this.blur;
                return this;
            };
            _super.finalizeInsert.call(this);
        };
        _.createLeftOf = function (cursor) {
            _super.createLeftOf.call(this, this.cursor = cursor);

            if (this.replacedText) for (var i = 0; i < this.replacedText.length; i += 1)
            this.ends[L].write(cursor, this.replacedText.charAt(i));
        };
    });

    var InnerTextBlock = P(MathBlock, function (_, _super) {
        _.onKey = function (key, e) {
            if (key === 'Spacebar' || key === 'Shift-Spacebar') return false;
        };
        // backspace and delete at ends of block don't unwrap
        _.deleteOutOf = function (dir, cursor) {
            if (this.isEmpty()) cursor.insRightOf(this.parent);
        };
        _.write = function (cursor, ch, replacedFragment) {
            if (replacedFragment) replacedFragment.remove();

            if (ch !== '$') {
                var html;
                if (ch === '<') html = '&lt;';
                else if (ch === '>') html = '&gt;';
                VanillaSymbol(ch, html).createLeftOf(cursor);
            } else if (this.isEmpty()) {
                cursor.insRightOf(this.parent).backspace();
                VanillaSymbol('\\$', '$').createLeftOf(cursor);
            } else if (!cursor[R]) cursor.insRightOf(this.parent);
            else if (!cursor[L]) cursor.insLeftOf(this.parent);
            else { //split apart
                var rightward = TextBlock();
                rightward.replaces(MathFragment(cursor[R], this.ends[R]));

                cursor.insRightOf(this.parent);

                // FIXME HACK: pretend no prev so they don't get merged when
                // .createLeftOf() calls blur on the InnerTextBlock
                rightward.adopt = function () {
                    delete this.adopt;
                    this.adopt.apply(this, arguments);
                    this[L] = 0;
                };
                rightward.createLeftOf(cursor);
                rightward[L] = this.parent;

                cursor.insLeftOf(rightward);
            }
            return false;
        };
        _.blur = function () {
            this.jQ.removeClass('hasCursor');
            if (this.isEmpty()) {
                var textblock = this.parent,
                    cursor = textblock.cursor;
                if (cursor.parent === this) this.jQ.addClass('empty');
                else {
                    cursor.hide();
                    textblock.remove();
                    if (cursor[R] === textblock) cursor[R] = textblock[R];
                    else if (cursor[L] === textblock) cursor[L] = textblock[L];

                    cursor.show().parent.bubble('redraw');
                }
            }
            return this;
        };
        _.focus = function () {
            _super.focus.call(this);

            var textblock = this.parent;
            if (textblock[R].ctrlSeq === textblock.ctrlSeq) { //TODO: seems like there should be a better way to move MathElements around
                var innerblock = this,
                    cursor = textblock.cursor,
                    rightward = textblock[R].ends[L];

                rightward.eachChild(function (child) {
                    child.parent = innerblock;
                    child.jQ.appendTo(innerblock.jQ);
                });

                if (this.ends[R]) this.ends[R][R] = rightward.ends[L];
                else this.ends[L] = rightward.ends[L];

                rightward.ends[L][L] = this.ends[R];
                this.ends[R] = rightward.ends[R];

                rightward.parent.remove();

                if (cursor[L]) cursor.insRightOf(cursor[L]);
                else cursor.insAtLeftEnd(this);

                cursor.parent.bubble('redraw');
            } else if (textblock[L].ctrlSeq === textblock.ctrlSeq) {
                var cursor = textblock.cursor;
                if (cursor[L]) textblock[L].ends[L].focus();
                else cursor.insAtRightEnd(textblock[L].ends[L]);
            }
            return this;
        };
    });


    function makeTextBlock(latex, tagName, attrs) {
        return P(TextBlock, {
            ctrlSeq: latex,
            htmlTemplate: '<' + tagName + ' ' + attrs + '>&0</' + tagName + '>'
        });
    }

    LatexCmds.em = LatexCmds.italic = LatexCmds.italics = LatexCmds.emph = LatexCmds.textit = LatexCmds.textsl = makeTextBlock('\\textit', 'i', 'class="text"');
    LatexCmds.strong = LatexCmds.bold = LatexCmds.textbf = makeTextBlock('\\textbf', 'b', 'class="text"');
    LatexCmds.sf = LatexCmds.textsf = makeTextBlock('\\textsf', 'span', 'class="sans-serif text"');
    LatexCmds.tt = LatexCmds.texttt = makeTextBlock('\\texttt', 'span', 'class="monospace text"');
    LatexCmds.textsc = makeTextBlock('\\textsc', 'span', 'style="font-variant:small-caps" class="text"');
    LatexCmds.uppercase = makeTextBlock('\\uppercase', 'span', 'style="text-transform:uppercase" class="text"');
    LatexCmds.lowercase = makeTextBlock('\\lowercase', 'span', 'style="text-transform:lowercase" class="text"');

    // input box to type a variety of LaTeX commands beginning with a backslash
    var LatexCommandInput = CharCmds['\\'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\';
        _.replaces = function (replacedFragment) {
            this._replacedFragment = replacedFragment.disown();
            this.isEmpty = function () {
                return false;
            };
        };
        _.htmlTemplate = '<span class="latex-command-input non-leaf">\\<span>&0</span></span>';
        _.textTemplate = ['\\'];
        _.createBlocks = function () {
            _super.createBlocks.call(this);
            this.ends[L].focus = function () {
                this.parent.jQ.addClass('hasCursor');
                if (this.isEmpty()) this.parent.jQ.removeClass('empty');

                return this;
            };
            this.ends[L].blur = function () {
                this.parent.jQ.removeClass('hasCursor');
                if (this.isEmpty()) this.parent.jQ.addClass('empty');

                return this;
            };
        };
        _.createLeftOf = function (cursor) {
            _super.createLeftOf.call(this, cursor);

            this.cursor = cursor.insAtRightEnd(this.ends[L]);
            if (this._replacedFragment) {
                var el = this.jQ[0];
                this.jQ = this._replacedFragment.jQ.addClass('blur').bind('mousedown mousemove', //FIXME: is monkey-patching the mousedown and mousemove handlers the right way to do this?


                function (e) {
                    $(e.target = el).trigger(e);
                    return false;
                }).insertBefore(this.jQ).add(this.jQ);
            }

            this.ends[L].write = function (cursor, ch, replacedFragment) {
                if (replacedFragment) replacedFragment.remove();

                if (ch.match(/[a-z]/i)) VanillaSymbol(ch).createLeftOf(cursor);
                else {
                    this.parent.renderCommand();
                    if (ch !== '\\' || !this.isEmpty()) this.parent.parent.write(cursor, ch);
                }
            };
        };
        _.latex = function () {
            return '\\' + this.ends[L].latex() + ' ';
        };
        _.onKey = function (key, e) {
            if (key === 'Tab' || key === 'Enter' || key === 'Spacebar') {
                this.renderCommand();
                e.preventDefault();
                return false;
            }
        };

        _.renderCommand = function () {
            this.jQ = this.jQ.last();
            this.remove();
            if (this[R]) {
                this.cursor.insLeftOf(this[R]);
            } else {
                this.cursor.insAtRightEnd(this.parent);
            }

            var latex = this.ends[L].latex(),
                cmd;
            if (!latex) latex = 'backslash';
            this.cursor.insertCmd(latex, this._replacedFragment);
        };

    });
    var Hept = LatexCmds.hept = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\hept';
        _.htmlTemplate =
         '<span class="non-leaf">'
         +'<span class="paren scaled">{</span>' 
         + '<span class="array non-leaf">' + '<span>&0</span>' + '</span>' + '</span>';
        _.textTemplate = ['choose(', ',', ')'];
        _.redraw = function () {
            var blockjQ = this.jQ.eq(-1);
            var jQ = this.jQ;
            var height = blockjQ.outerHeight() / +blockjQ.css('fontSize').slice(0, -2);

            var bracket =jQ.children(':first');
            scale(bracket, min(1 + .2 * (height - 1), 1.2), 1.05 * height);
        };
    });

    var Binomial = LatexCmds.binom = LatexCmds.binomial = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\binom';
        _.htmlTemplate = '<span class="paren scaled">(</span>' + '<span class="non-leaf">' + '<span class="array non-leaf">' + '<span>&0</span>' + '<span>&1</span>' + '</span>' + '</span>' + '<span class="paren scaled">)</span>';
        _.textTemplate = ['choose(', ',', ')'];
        _.redraw = function () {
            var blockjQ = this.jQ.eq(1);

            var height = blockjQ.outerHeight() / +blockjQ.css('fontSize').slice(0, -2);

            var parens = this.jQ.filter('.paren');
            scale(parens, min(1 + .2 * (height - 1), 1.2), 1.05 * height);
        };
    });

    var Choose = LatexCmds.choose = P(Binomial, function (_) {
        _.createLeftOf = LiveFraction.prototype.createLeftOf;
    });


    LatexCmds.editable = P(RootMathCommand, function (_, _super) {
        _.init = function () {
            MathCommand.prototype.init.call(this, '\\editable');
        };

        _.jQadd = function () {
            var self = this;
            // FIXME: this entire method is a giant hack to get around
            // having to call createBlocks, and createRoot expecting to
            // render the contents' LaTeX. Both need to be refactored.
            _super.jQadd.apply(self, arguments);
            var block = self.ends[L].disown();
            var blockjQ = self.jQ.children().detach();

            self.ends[L] = self.ends[R] = RootMathBlock();

            self.blocks = [self.ends[L]];

            self.ends[L].parent = self;

            createRoot(self.jQ, self.ends[L], false, true);
            self.cursor = self.ends[L].cursor;

            block.children().adopt(self.ends[L], 0, 0);
            blockjQ.appendTo(self.ends[L].jQ);

            self.ends[L].cursor.insAtRightEnd(self.ends[L]);
        };

        _.latex = function () {
            return this.ends[L].latex();
        };
        _.text = function () {
            return this.ends[L].text();
        };
    });
    /**********************************
     * Symbols and Special Characters
     *********************************/

    LatexCmds.f = bind(Symbol, 'f', '<var class="florin">&fnof;</var><span style="display:inline-block;width:0">&nbsp;</span>');

    var Variable = P(Symbol, function (_, _super) {
        _.init = function (ch, html) {
            _super.init.call(this, ch, '<var>' + (html || ch) + '</var>');
        };
        _.text = function () {
            var text = this.ctrlSeq;
            if (this[L] && !(this[L] instanceof Variable) && !(this[L] instanceof BinaryOperator)) text = '*' + text;
            if (this[R] && !(this[R] instanceof BinaryOperator) && !(this[R].ctrlSeq === '^')) text += '*';
            return text;
        };
    });

    var VanillaSymbol = P(Symbol, function (_, _super) {
        _.init = function (ch, html) {
            _super.init.call(this, ch, '<span>' + (html || ch) + '</span>');
        };
    });

    //CharCmds[' '] = bind(VanillaSymbol, '\\:', ' ');
    //LatexCmds['\,'] = LatexCmds.thinspace = bind(VanillaSymbol, '\\, ', ' ');
    LatexCmds['kksp'] = CharCmds[' '] = bind(VanillaSymbol, '\\:', ' ');


    LatexCmds.prime = CharCmds["'"] = bind(VanillaSymbol, "'", '&prime;');

    // does not use Symbola font
    var NonSymbolaSymbol = P(Symbol, function (_, _super) {
        _.init = function (ch, html) {
            _super.init.call(this, ch, '<span class="nonSymbola">' + (html || ch) + '</span>');
        };
    });

    LatexCmds['@'] = NonSymbolaSymbol;
    LatexCmds['&'] = bind(NonSymbolaSymbol, '\\&', '&amp;');
    LatexCmds['%'] = bind(NonSymbolaSymbol, '\\%', '%');

    //the following are all Greek to me, but this helped a lot: http://www.ams.org/STIX/ion/stixsig03.html
    //lowercase Greek letter variables
    LatexCmds.alpha = LatexCmds.beta = LatexCmds.gamma = LatexCmds.delta = LatexCmds.zeta = LatexCmds.eta = LatexCmds.theta = LatexCmds.iota = LatexCmds.kappa = LatexCmds.mu = LatexCmds.nu = LatexCmds.xi = LatexCmds.rho = LatexCmds.sigma = LatexCmds.tau = LatexCmds.chi = LatexCmds.psi = LatexCmds.omega = P(Variable, function (_, _super) {
        _.init = function (latex) {
            _super.init.call(this, '\\' + latex + ' ', '&' + latex + ';');
        };
    });

    //why can't anybody FUCKING agree on these
    LatexCmds.phi = //W3C or Unicode?
    bind(Variable, '\\phi ', '&#981;');

    LatexCmds.phiv = //Elsevier and 9573-13
    LatexCmds.varphi = //AMS and LaTeX
    bind(Variable, '\\varphi ', '&phi;');

    LatexCmds.epsilon = //W3C or Unicode?
    bind(Variable, '\\epsilon ', '&#1013;');

    LatexCmds.epsiv = //Elsevier and 9573-13
    LatexCmds.varepsilon = //AMS and LaTeX
    bind(Variable, '\\varepsilon ', '&epsilon;');

    LatexCmds.piv = //W3C/Unicode and Elsevier and 9573-13
    LatexCmds.varpi = //AMS and LaTeX
    bind(Variable, '\\varpi ', '&piv;');

    LatexCmds.sigmaf = //W3C/Unicode
    LatexCmds.sigmav = //Elsevier
    LatexCmds.varsigma = //LaTeX
    bind(Variable, '\\varsigma ', '&sigmaf;');

    LatexCmds.thetav = //Elsevier and 9573-13
    LatexCmds.vartheta = //AMS and LaTeX
    LatexCmds.thetasym = //W3C/Unicode
    bind(Variable, '\\vartheta ', '&thetasym;');

    LatexCmds.upsilon = //AMS and LaTeX and W3C/Unicode
    LatexCmds.upsi = //Elsevier and 9573-13
    bind(Variable, '\\upsilon ', '&upsilon;');

    //these aren't even mentioned in the HTML character entity references
    LatexCmds.gammad = //Elsevier
    LatexCmds.Gammad = //9573-13 -- WTF, right? I dunno if this was a typo in the reference (see above)
    LatexCmds.digamma = //LaTeX
    bind(Variable, '\\digamma ', '&#989;');

    LatexCmds.kappav = //Elsevier
    LatexCmds.varkappa = //AMS and LaTeX
    bind(Variable, '\\varkappa ', '&#1008;');

    LatexCmds.rhov = //Elsevier and 9573-13
    LatexCmds.varrho = //AMS and LaTeX
    bind(Variable, '\\varrho ', '&#1009;');

    //Greek constants, look best in un-italicised Times New Roman
    LatexCmds.pi = LatexCmds['π'] = bind(NonSymbolaSymbol, '\\pi ', '&pi;');
    LatexCmds.lambda = bind(NonSymbolaSymbol, '\\lambda ', '&lambda;');

    //uppercase greek letters
    LatexCmds.Upsilon = //LaTeX
    LatexCmds.Upsi = //Elsevier and 9573-13
    LatexCmds.upsih = //W3C/Unicode "upsilon with hook"
    LatexCmds.Upsih = //'cos it makes sense to me
    bind(Symbol, '\\Upsilon ', '<var style="font-family: serif">&upsih;</var>'); //Symbola's 'upsilon with a hook' is a capital Y without hooks :(
    //other symbols with the same LaTeX command and HTML character entity reference
    LatexCmds.Gamma = LatexCmds.Delta = LatexCmds.Theta = LatexCmds.Lambda = LatexCmds.Xi = LatexCmds.Pi = LatexCmds.Sigma = LatexCmds.Phi = LatexCmds.Psi = LatexCmds.Omega = LatexCmds.forall = P(VanillaSymbol, function (_, _super) {
        _.init = function (latex) {
            _super.init.call(this, '\\' + latex + ' ', '&' + latex + ';');
        };
    });

    // symbols that aren't a single MathCommand, but are instead a whole
    // Fragment. Creates the Fragment from a LaTeX string
    var LatexFragment = P(MathCommand, function (_) {
        _.init = function (latex) {
            this.latex = latex;
        };
        _.createLeftOf = function (cursor) {
            cursor.writeLatex(this.latex);
        };
        _.parser = function () {
            var frag = latexMathParser.parse(this.latex).children();
            return Parser.succeed(frag);
        };
    });

    // for what seems to me like [stupid reasons][1], Unicode provides
    // subscripted and superscripted versions of all ten Arabic numerals,
    // as well as [so-called "vulgar fractions"][2].
    // Nobody really cares about most of them, but some of them actually
    // predate Unicode, dating back to [ISO-8859-1][3], apparently also
    // known as "Latin-1", which among other things [Windows-1252][4]
    // largely coincides with, so Microsoft Word sometimes inserts them
    // and they get copy-pasted into MathQuill.
    //
    // (Irrelevant but funny story: Windows-1252 is actually a strict
    // superset of the "closely related but distinct"[3] "ISO 8859-1" --
    // see the lack of a dash after "ISO"? Completely different character
    // set, like elephants vs elephant seals, or "Zombies" vs "Zombie
    // Redneck Torture Family". What kind of idiot would get them confused.
    // People in fact got them confused so much, it was so common to
    // mislabel Windows-1252 text as ISO-8859-1, that most modern web
    // browsers and email clients treat the MIME charset of ISO-8859-1
    // as actually Windows-1252, behavior now standard in the HTML5 spec.)
    //
    // [1]: http://en.wikipedia.org/wiki/Unicode_subscripts_and_superscripts
    // [2]: http://en.wikipedia.org/wiki/Number_Forms
    // [3]: http://en.wikipedia.org/wiki/ISO/IEC_8859-1
    // [4]: http://en.wikipedia.org/wiki/Windows-1252
    LatexCmds['¹'] = bind(LatexFragment, '^1');
    LatexCmds['²'] = bind(LatexFragment, '^2');
    LatexCmds['³'] = bind(LatexFragment, '^3');
    LatexCmds['¼'] = bind(LatexFragment, '\\frac14');
    LatexCmds['½'] = bind(LatexFragment, '\\frac12');
    LatexCmds['¾'] = bind(LatexFragment, '\\frac34');

    var BinaryOperator = P(Symbol, function (_, _super) {
        _.init = function (ctrlSeq, html, text) {
            _super.init.call(this, ctrlSeq, '<span class="binary-operator">' + html + '</span>', text);
        };
    });

    var PlusMinus = P(BinaryOperator, function (_) {
        _.init = VanillaSymbol.prototype.init;

        _.respace = function () {
            if (!this[L]) {
                this.jQ[0].className = '';
            } else if (
            this[L] instanceof BinaryOperator && this[R] && !(this[R] instanceof BinaryOperator)) {
                this.jQ[0].className = 'unary-operator';
            } else {
                this.jQ[0].className = 'binary-operator';
            }
            return this;
        };
    });

    LatexCmds['+'] = bind(PlusMinus, '+', '+');
    //yes, these are different dashes, I think one is an en dash and the other is a hyphen
    LatexCmds['–'] = LatexCmds['-'] = bind(PlusMinus, '-', '&minus;');
    LatexCmds['±'] = LatexCmds.pm = LatexCmds.plusmn = LatexCmds.plusminus = bind(PlusMinus, '\\pm ', '&plusmn;');
    LatexCmds.mp = LatexCmds.mnplus = LatexCmds.minusplus = bind(PlusMinus, '\\mp ', '&#8723;');

    CharCmds['*'] = LatexCmds.sdot = LatexCmds.cdot = bind(BinaryOperator, '\\cdot ', '&middot;');
    //semantically should be &sdot;, but &middot; looks better
    LatexCmds['='] = bind(BinaryOperator, '=', '=');
    LatexCmds['<'] = bind(BinaryOperator, '<', '&lt;');
    LatexCmds['>'] = bind(BinaryOperator, '>', '&gt;');

    LatexCmds.notin = LatexCmds.sim = LatexCmds.cong = LatexCmds.equiv = LatexCmds.oplus = LatexCmds.otimes = P(BinaryOperator, function (_, _super) {
        _.init = function (latex) {
            _super.init.call(this, '\\' + latex + ' ', '&' + latex + ';');
        };
    });

    LatexCmds.times = bind(BinaryOperator, '\\times ', '&times;', '[x]');

    LatexCmds['÷'] = LatexCmds.div = LatexCmds.divide = LatexCmds.divides = bind(BinaryOperator, '\\div ', '&divide;', '[/]');

    LatexCmds['⋇'] = LatexCmds.divideontimes = bind(BinaryOperator, '\\divideontimes ', '&#8903;', '[⋇]');
    LatexCmds['∔'] = LatexCmds.dotplus = bind(BinaryOperator, '\\dotplus ', '&#8724;', '∔');
    LatexCmds['⋉'] = LatexCmds.ltimes = bind(BinaryOperator, '\\ltimes ', '&#8905;', '⋉');
    LatexCmds['⋊'] = LatexCmds.rtimes = bind(BinaryOperator, '\\rtimes ', '&#8906;', '⋊');
    LatexCmds['⋌'] = LatexCmds.rightthreetimes = bind(BinaryOperator, '\\rightthreetimes ', '&#8908;', '⋌');
    LatexCmds['⋋'] = LatexCmds.leftthreetimes = bind(BinaryOperator, '\\leftthreetimes ', '&#8907;', '⋋');
    LatexCmds['╱'] = LatexCmds.diagup = bind(BinaryOperator, '\\diagup ', '&#x2571;', '╱');
    LatexCmds['╲'] = LatexCmds.diagdown = bind(BinaryOperator, '\\diagdown ', '&#x2572;', '╲');
    LatexCmds['⊼'] = LatexCmds.barwedge = bind(BinaryOperator, '\\barwedge ', '&#x22BC;', '⊼');
    LatexCmds['⊻'] = LatexCmds.veebar = bind(BinaryOperator, '\\veebar ', '&#x22BB;', '⊻');
    LatexCmds['⌆'] = LatexCmds.doublebarwedge = bind(BinaryOperator, '\\doublebarwedge ', '&#x2306;', '⌆');
    LatexCmds['⋎'] = LatexCmds.curlyvee = bind(BinaryOperator, '\\curlyvee ', '&#x22CE;', '⋎');
    LatexCmds['⋏'] = LatexCmds.curlywedge = bind(BinaryOperator, '\\curlywedge ', '&#x22CF;', '⋏');
    LatexCmds['⋒'] = LatexCmds.Cap = bind(BinaryOperator, '\\Cap ', '&#x22D3;', '⋒');
    LatexCmds['⋓'] = LatexCmds.Cup = bind(BinaryOperator, '\\Cup ', '&#x22D2;', '⋓');
    LatexCmds['⊚'] = LatexCmds.circledcirc = bind(BinaryOperator, '\\circledcirc ', '&#x229A;', '⊚');
    LatexCmds['⊛'] = LatexCmds.circledast = bind(BinaryOperator, '\\circledast ', '&#x229B;', '⊛');
    LatexCmds['⊝'] = LatexCmds.circleddash = bind(BinaryOperator, '\\circleddash ', '&#x229D;', '⊝');
    LatexCmds['⊠'] = LatexCmds.boxtimes = bind(BinaryOperator, '\\boxtimes ', '&#x22A0;', '⊠');
    LatexCmds['⊡'] = LatexCmds.boxdot = bind(BinaryOperator, '\\boxdot ', '&#x22A1;', '⊡');
    LatexCmds['⊞'] = LatexCmds.boxplus = bind(BinaryOperator, '\\boxplus ', '&#x229E;', '⊞');
    LatexCmds['⊟'] = LatexCmds.boxminus = bind(BinaryOperator, '\\boxminus ', '&#x229F;', '⊟');
    LatexCmds['⊺'] = LatexCmds.intercal = bind(BinaryOperator, '\\intercal ', '&#x22BA;', '⊺');
    LatexCmds['≠'] = LatexCmds.ne = LatexCmds.neq = bind(BinaryOperator, '\\ne ', '&ne;');

/*var Bar =
    LatexCmds.bar =
    LatexCmds['bar'] = P(MathCommand, function (_, _super) {
        _.ctrlSeq = '\\bar';
        _.htmlTemplate =
            '<span class="non-leaf">'
          + '<span class="bar-prefix">&#x203E;</span>'
          + '<span class="vector-stem">&0</span>'
          + '</span>'
        ;
        _.textTemplate = ['bar{', '}'];
    });*/


    LatexCmds.ast = LatexCmds.star = LatexCmds.loast = LatexCmds.lowast = bind(BinaryOperator, '\\ast ', '&lowast;');
    //case 'there4 = // a special exception for this one, perhaps?
    LatexCmds.therefor = LatexCmds.therefore = bind(BinaryOperator, '\\therefore ', '&there4;');

    LatexCmds.cuz = // l33t
    LatexCmds.because = bind(BinaryOperator, '\\because ', '&#8757;');

    LatexCmds.prop = LatexCmds.propto = bind(BinaryOperator, '\\propto ', '&prop;');

    LatexCmds['≈'] = LatexCmds.asymp = LatexCmds.approx = bind(BinaryOperator, '\\approx ', '&asymp;');

    LatexCmds.lt = bind(BinaryOperator, '<', '&lt;');

    LatexCmds.gt = bind(BinaryOperator, '>', '&gt;');

    LatexCmds['≤'] = LatexCmds.le = LatexCmds.leq = bind(BinaryOperator, '\\le ', '&le;');

    LatexCmds['≥'] = LatexCmds.ge = LatexCmds.geq = LatexCmds.geqslant = bind(BinaryOperator, '\\ge ', '&ge;');

    LatexCmds.isin = LatexCmds['in'] = bind(BinaryOperator, '\\in ', '&isin;');

    LatexCmds.ni = LatexCmds.contains = bind(BinaryOperator, '\\ni ', '&ni;');

    LatexCmds.notni = LatexCmds.niton = LatexCmds.notcontains = LatexCmds.doesnotcontain = bind(BinaryOperator, '\\not\\ni ', '&#8716;');

    LatexCmds.sub = LatexCmds.subset = bind(BinaryOperator, '\\subset ', '&sub;');

    LatexCmds.sup = LatexCmds.supset = LatexCmds.superset = bind(BinaryOperator, '\\supset ', '&sup;');

    LatexCmds.nsub = LatexCmds.notsub = LatexCmds.nsubset = LatexCmds.notsubset = bind(BinaryOperator, '\\not\\subset ', '&#8836;');

    LatexCmds.nsup = LatexCmds.notsup = LatexCmds.nsupset = LatexCmds.notsupset = LatexCmds.nsuperset = LatexCmds.notsuperset = bind(BinaryOperator, '\\not\\supset ', '&#8837;');

    LatexCmds.sube = LatexCmds.subeq = LatexCmds.subsete = LatexCmds.subseteq = bind(BinaryOperator, '\\subseteq ', '&sube;');

    LatexCmds.supe = LatexCmds.supeq = LatexCmds.supsete = LatexCmds.supseteq = LatexCmds.supersete = LatexCmds.superseteq = bind(BinaryOperator, '\\supseteq ', '&supe;');

    LatexCmds.nsube = LatexCmds.nsubeq = LatexCmds.notsube = LatexCmds.notsubeq = LatexCmds.nsubsete = LatexCmds.nsubseteq = LatexCmds.notsubsete = LatexCmds.notsubseteq = bind(BinaryOperator, '\\not\\subseteq ', '&#8840;');

    LatexCmds.nsupe = LatexCmds.nsupeq = LatexCmds.notsupe = LatexCmds.notsupeq = LatexCmds.nsupsete = LatexCmds.nsupseteq = LatexCmds.notsupsete = LatexCmds.notsupseteq = LatexCmds.nsupersete = LatexCmds.nsuperseteq = LatexCmds.notsupersete = LatexCmds.notsuperseteq = bind(BinaryOperator, '\\not\\supseteq ', '&#8841;');


    //sum, product, coproduct, integral
    var BigSymbol = P(Symbol, function (_, _super) {
        _.init = function (ch, html) {
            _super.init.call(this, ch, '<big>' + html + '</big>');
        };
    });

    LatexCmds['limlimits'] = LatexCmds['lim\limits'] = LatexCmds.summation = bind(BigSymbol, '\\lim\\limits ', 'lim');
    LatexCmds['∑'] = LatexCmds.sum = LatexCmds.summation = bind(BigSymbol, '\\sum ', '&sum;');
    LatexCmds['∑'] = LatexCmds['sumlimits'] = LatexCmds['sum\limits'] = LatexCmds.summation = bind(BigSymbol, '\\sum\\limits ', '&sum;');

    LatexCmds['∏'] = LatexCmds.prod = LatexCmds.product = bind(BigSymbol, '\\prod ', '&prod;');
    LatexCmds['prodlimits'] =LatexCmds['prod\limits'] = bind(BigSymbol, '\\prod\\limits ', '&prod;');
    LatexCmds.coprod = LatexCmds.coproduct = bind(BigSymbol, '\\coprod ', '&#8720;');
    LatexCmds['coprodlimits'] =LatexCmds['coprod\limits'] = bind(BigSymbol, '\\coprod\\limits ', '&#8720;');
    LatexCmds['∫'] = LatexCmds['intlimits'] = LatexCmds['int\limits'] = LatexCmds.integral = bind(BigSymbol, '\\int\\limits ', '&int;');
    LatexCmds['∫'] = LatexCmds['int'] = LatexCmds.integral = bind(BigSymbol, '\\int ', '&int;');
    LatexCmds['∫∫'] = LatexCmds['iint'] = LatexCmds.iintegral = bind(BigSymbol, '\\iint ', '&#x222c;');
    LatexCmds['∫∫'] = LatexCmds['iintlimits'] = LatexCmds['iint\limits'] = LatexCmds.iintegral = bind(BigSymbol, '\\iint\\limits ', '&#x222c;');
    LatexCmds['∫∫∫'] = LatexCmds['iiint'] = LatexCmds.iiintegral = bind(BigSymbol, '\\iiint ', '&iiint;');
    LatexCmds['∫∫∫'] = LatexCmds['iiintlimits'] = LatexCmds['iiint\limits'] = LatexCmds.iiintegral = bind(BigSymbol, '\\iiint\\limits ', '&iiint;');
    LatexCmds['∫∫∫∫'] = LatexCmds['iiiint'] = LatexCmds.iiiintegral = bind(BigSymbol, '\\iiiint ', '&iiiint;');
    LatexCmds['∫∫∫∫'] = LatexCmds['iiiintlimits'] = LatexCmds['iiiint\limits'] = LatexCmds.iiiintegral = bind(BigSymbol, '\\iiiint\\limits ', '&iiiint;');
    LatexCmds.oint = bind(VanillaSymbol, '\\oint ', '&#8750;');
    LatexCmds.ointlimits = LatexCmds['oint\limits'] = bind(VanillaSymbol, '\\oint\\limits ', '&#8750;');
    //the canonical sets of numbers
    LatexCmds.N = LatexCmds.naturals = LatexCmds.Naturals = bind(VanillaSymbol, '\\mathbb{N}', '&#8469;');

    LatexCmds.P = LatexCmds.primes = LatexCmds.Primes = LatexCmds.projective = LatexCmds.Projective = LatexCmds.probability = LatexCmds.Probability = bind(VanillaSymbol, '\\mathbb{P}', '&#8473;');

    LatexCmds.Z = LatexCmds.integers = LatexCmds.Integers = bind(VanillaSymbol, '\\mathbb{Z}', '&#8484;');

    LatexCmds.Q = LatexCmds.rationals = LatexCmds.Rationals = bind(VanillaSymbol, '\\mathbb{Q}', '&#8474;');

    LatexCmds.R = LatexCmds.reals = LatexCmds.Reals = bind(VanillaSymbol, '\\mathbb{R}', '&#8477;');

    LatexCmds.C = LatexCmds.complex = LatexCmds.Complex = LatexCmds.complexes = LatexCmds.Complexes = LatexCmds.complexplane = LatexCmds.Complexplane = LatexCmds.ComplexPlane = bind(VanillaSymbol, '\\mathbb{C}', '&#8450;');

    LatexCmds.H = LatexCmds.Hamiltonian = LatexCmds.quaternions = LatexCmds.Quaternions = bind(VanillaSymbol, '\\mathbb{H}', '&#8461;');

    //spacing
    LatexCmds.quad = LatexCmds.emsp = bind(VanillaSymbol, '\\quad ', '&#160;&#160;');
    LatexCmds.qquad = bind(VanillaSymbol, '\\qquad ', '&#160;&#160;&#160;&#160;');
    LatexCmds.thinspace = bind(VanillaSymbol, '\\, ', '&#8202;');
    LatexCmds.thickspace = bind(VanillaSymbol, '\\; ', '&#160;');
    LatexCmds.mediumspace = bind(VanillaSymbol, '\\: ', '&#8201;');
    LatexCmds.enter = bind(VanillaSymbol, '\\\\ ', ' \\\\\n');

    LatexCmds.thinspace = bind(VanillaSymbol, '\\, ', ' ');
/* spacing special characters, gonna have to implement this in LatexCommandInput::onText somehow
    case ',':
      return VanillaSymbol('\\, ',' ');
    case ':':
      return VanillaSymbol('\\: ','  ');
    case ';':
      return VanillaSymbol('\\; ','   ');
    case '!':
      return Symbol('\\! ','<span style="margin-right:-.2em"></span>');
    */

    //binary operators
    LatexCmds.diamond = bind(VanillaSymbol, '\\diamond ', '&#9671;');
    LatexCmds.bigtriangleup = bind(VanillaSymbol, '\\bigtriangleup ', '&#9651;');
    LatexCmds.ominus = bind(VanillaSymbol, '\\ominus ', '&#8854;');
    LatexCmds.uplus = bind(VanillaSymbol, '\\uplus ', '&#8846;');
    LatexCmds.bigtriangledown = bind(VanillaSymbol, '\\bigtriangledown ', '&#9661;');
    LatexCmds.sqcap = bind(VanillaSymbol, '\\sqcap ', '&#8851;');
    LatexCmds.triangleleft = bind(VanillaSymbol, '\\triangleleft ', '&#8882;');
    LatexCmds.sqcup = bind(VanillaSymbol, '\\sqcup ', '&#8852;');
    LatexCmds.triangleright = bind(VanillaSymbol, '\\triangleright ', '&#8883;');
    LatexCmds.odot = bind(VanillaSymbol, '\\odot ', '&#8857;');
    LatexCmds.bigcirc = bind(VanillaSymbol, '\\bigcirc ', '&#9711;');
    LatexCmds.dagger = bind(VanillaSymbol, '\\dagger ', '&#0134;');
    LatexCmds.ddagger = bind(VanillaSymbol, '\\ddagger ', '&#135;');
    LatexCmds.wr = bind(VanillaSymbol, '\\wr ', '&#8768;');
    LatexCmds.amalg = bind(VanillaSymbol, '\\amalg ', '&#8720;');

    //relationship symbols
    LatexCmds.models = bind(VanillaSymbol, '\\models ', '&#8872;');
    LatexCmds.prec = bind(VanillaSymbol, '\\prec ', '&#8826;');
    LatexCmds.succ = bind(VanillaSymbol, '\\succ ', '&#8827;');
    LatexCmds.preceq = bind(VanillaSymbol, '\\preceq ', '&#8828;');
    LatexCmds.succeq = bind(VanillaSymbol, '\\succeq ', '&#8829;');
    LatexCmds.simeq = bind(VanillaSymbol, '\\simeq ', '&#8771;');
    LatexCmds.mid = bind(VanillaSymbol, '\\mid ', '&#8739;');
    LatexCmds.ll = bind(VanillaSymbol, '\\ll ', '&#8810;');
    LatexCmds.gg = bind(VanillaSymbol, '\\gg ', '&#8811;');
    LatexCmds.parallel = bind(VanillaSymbol, '\\parallel ', '&#8741;');
    LatexCmds.bowtie = bind(VanillaSymbol, '\\bowtie ', '&#8904;');
    LatexCmds.sqsubset = bind(VanillaSymbol, '\\sqsubset ', '&#8847;');
    LatexCmds.sqsupset = bind(VanillaSymbol, '\\sqsupset ', '&#8848;');
    LatexCmds.smile = bind(VanillaSymbol, '\\smile ', '&#8995;');
    LatexCmds.sqsubseteq = bind(VanillaSymbol, '\\sqsubseteq ', '&#8849;');
    LatexCmds.sqsupseteq = bind(VanillaSymbol, '\\sqsupseteq ', '&#8850;');
    LatexCmds.doteq = bind(VanillaSymbol, '\\doteq ', '&#8784;');
    LatexCmds.doteqdot = bind(VanillaSymbol, '\\doteqdot ', '&#x2251;');
    LatexCmds.frown = bind(VanillaSymbol, '\\frown ', '&#8994;');
    LatexCmds.vdash = bind(VanillaSymbol, '\\vdash ', '&#8870;');
    LatexCmds.dashv = bind(VanillaSymbol, '\\dashv ', '&#8867;');

    //arrows
    LatexCmds.longleftarrow = bind(VanillaSymbol, '\\longleftarrow ', '&#8592;');
    LatexCmds.longrightarrow = bind(VanillaSymbol, '\\longrightarrow ', '&#8594;');
    LatexCmds.Longleftarrow = bind(VanillaSymbol, '\\Longleftarrow ', '&#8656;');
    LatexCmds.Longrightarrow = bind(VanillaSymbol, '\\Longrightarrow ', '&#8658;');
    LatexCmds.longleftrightarrow = bind(VanillaSymbol, '\\longleftrightarrow ', '&#8596;');
    LatexCmds.updownarrow = bind(VanillaSymbol, '\\updownarrow ', '&#8597;');
    LatexCmds.Longleftrightarrow = bind(VanillaSymbol, '\\Longleftrightarrow ', '&#8660;');
    LatexCmds.Updownarrow = bind(VanillaSymbol, '\\Updownarrow ', '&#8661;');
    LatexCmds.mapsto = bind(VanillaSymbol, '\\mapsto ', '&#8614;');
    LatexCmds.nearrow = bind(VanillaSymbol, '\\nearrow ', '&#8599;');
    LatexCmds.hookleftarrow = bind(VanillaSymbol, '\\hookleftarrow ', '&#8617;');
    LatexCmds.hookrightarrow = bind(VanillaSymbol, '\\hookrightarrow ', '&#8618;');
    LatexCmds.searrow = bind(VanillaSymbol, '\\searrow ', '&#8600;');
    LatexCmds.leftharpoonup = bind(VanillaSymbol, '\\leftharpoonup ', '&#8636;');
    LatexCmds.rightharpoonup = bind(VanillaSymbol, '\\rightharpoonup ', '&#8640;');
    LatexCmds.swarrow = bind(VanillaSymbol, '\\swarrow ', '&#8601;');
    LatexCmds.leftharpoondown = bind(VanillaSymbol, '\\leftharpoondown ', '&#8637;');
    LatexCmds.rightharpoondown = bind(VanillaSymbol, '\\rightharpoondown ', '&#8641;');
    LatexCmds.nwarrow = bind(VanillaSymbol, '\\nwarrow ', '&#8598;');

    //Misc
    LatexCmds.ldots = bind(VanillaSymbol, '\\ldots ', '&#8230;');
    //LatexCmds.cdots = bind(VanillaSymbol, '\\cdots ', '&#8943;');
    //LatexCmds.vdots = bind(VanillaSymbol, '\\vdots ', '&#8942;');
    LatexCmds.ddots = bind(VanillaSymbol, '\\ddots ', '&#8944;');
    LatexCmds.surd = bind(VanillaSymbol, '\\surd ', '&#8730;');
    LatexCmds.triangle = bind(VanillaSymbol, '\\triangle ', '&#9653;');
    LatexCmds.ell = bind(VanillaSymbol, '\\ell ', '&#8467;');
    LatexCmds.top = bind(VanillaSymbol, '\\top ', '&#8868;');
    LatexCmds.flat = bind(VanillaSymbol, '\\flat ', '&#9837;');
    LatexCmds.natural = bind(VanillaSymbol, '\\natural ', '&#9838;');
    LatexCmds.sharp = bind(VanillaSymbol, '\\sharp ', '&#9839;');
    LatexCmds.wp = bind(VanillaSymbol, '\\wp ', '&#8472;');
    LatexCmds.bot = bind(VanillaSymbol, '\\bot ', '&#8869;');
    LatexCmds.clubsuit = bind(VanillaSymbol, '\\clubsuit ', '&#9827;');
    LatexCmds.diamondsuit = bind(VanillaSymbol, '\\diamondsuit ', '&#9826;');
    LatexCmds.heartsuit = bind(VanillaSymbol, '\\heartsuit ', '&#9825;');
    LatexCmds.spadesuit = bind(VanillaSymbol, '\\spadesuit ', '&#9824;');

    //variable-sized
    LatexCmds.oiint = bind(VanillaSymbol, '\\oiint ', '&#8751;');
    LatexCmds.oiiint = bind(VanillaSymbol, '\\oiiint ', '&#8752;');
    LatexCmds.bigcap = bind(VanillaSymbol, '\\bigcap ', '&#8745;');
    LatexCmds.bigcup = bind(VanillaSymbol, '\\bigcup ', '&#8746;');
    LatexCmds.bigsqcup = bind(VanillaSymbol, '\\bigsqcup ', '&#8852;');
    LatexCmds.bigvee = bind(VanillaSymbol, '\\bigvee ', '&#8744;');
    LatexCmds.bigwedge = bind(VanillaSymbol, '\\bigwedge ', '&#8743;');
    LatexCmds.bigodot = bind(VanillaSymbol, '\\bigodot ', '&#8857;');
    LatexCmds.bigotimes = bind(VanillaSymbol, '\\bigotimes ', '&#8855;');
    LatexCmds.bigoplus = bind(VanillaSymbol, '\\bigoplus ', '&#8853;');
    LatexCmds.biguplus = bind(VanillaSymbol, '\\biguplus ', '&#8846;');

    //delimiters
    LatexCmds.lfloor = bind(VanillaSymbol, '\\lfloor ', '&#8970;');
    LatexCmds.rfloor = bind(VanillaSymbol, '\\rfloor ', '&#8971;');
    LatexCmds.lceil = bind(VanillaSymbol, '\\lceil ', '&#8968;');
    LatexCmds.rceil = bind(VanillaSymbol, '\\rceil ', '&#8969;');
    LatexCmds.slash = bind(VanillaSymbol, '\\slash ', '&#47;');
    LatexCmds.opencurlybrace = bind(VanillaSymbol, '\\opencurlybrace ', '&#123;');
    LatexCmds.closecurlybrace = bind(VanillaSymbol, '\\closecurlybrace ', '&#125;');

    //various symbols
    LatexCmds.caret = bind(VanillaSymbol, '\\caret ', '^');
    LatexCmds.underscore = bind(VanillaSymbol, '\\underscore ', '_');
    LatexCmds.backslash = bind(VanillaSymbol, '\\backslash ', '\\');
    LatexCmds.vert = bind(VanillaSymbol, '|');
    LatexCmds.perp = LatexCmds.perpendicular = bind(VanillaSymbol, '\\perp ', '&perp;');
    LatexCmds.nabla = LatexCmds.del = bind(VanillaSymbol, '\\nabla ', '&nabla;');
    LatexCmds.hbar = bind(VanillaSymbol, '\\hbar ', '&#8463;');

    LatexCmds.AA = LatexCmds.Angstrom = LatexCmds.angstrom = bind(VanillaSymbol, '\\text\\AA ', '&#8491;');

    LatexCmds.ring = LatexCmds.circ = LatexCmds.circle = bind(VanillaSymbol, '\\circ ', '&#8728;');

    LatexCmds.bull = LatexCmds.bullet = bind(VanillaSymbol, '\\bullet ', '&bull;');

    LatexCmds.setminus = LatexCmds.smallsetminus = bind(VanillaSymbol, '\\setminus ', '&#8726;');

    LatexCmds.not = //bind(Symbol,'\\not ','<span class="not">/</span>');
    LatexCmds['¬'] = LatexCmds.neg = bind(VanillaSymbol, '\\neg ', '&not;');

    LatexCmds['…'] = LatexCmds.dots = LatexCmds.ellip = LatexCmds.hellip = LatexCmds.ellipsis = LatexCmds.hellipsis = bind(VanillaSymbol, '\\dots ', '&hellip;');

    LatexCmds.converges = LatexCmds.darr = LatexCmds.dnarr = LatexCmds.dnarrow = LatexCmds.downarrow = bind(VanillaSymbol, '\\downarrow ', '&darr;');

    LatexCmds.dArr = LatexCmds.dnArr = LatexCmds.dnArrow = LatexCmds.Downarrow = bind(VanillaSymbol, '\\Downarrow ', '&dArr;');

    LatexCmds.diverges = LatexCmds.uarr = LatexCmds.uparrow = bind(VanillaSymbol, '\\uparrow ', '&uarr;');

    LatexCmds.uArr = LatexCmds.Uparrow = bind(VanillaSymbol, '\\Uparrow ', '&uArr;');

    LatexCmds.to = bind(BinaryOperator, '\\to ', '&rarr;');

    LatexCmds.rarr = LatexCmds.rightarrow = bind(VanillaSymbol, '\\rightarrow ', '&rarr;');

    LatexCmds.implies = bind(BinaryOperator, '\\Rightarrow ', '&rArr;');

    LatexCmds.rArr = LatexCmds.Rightarrow = bind(VanillaSymbol, '\\Rightarrow ', '&rArr;');

    LatexCmds.gets = bind(BinaryOperator, '\\gets ', '&larr;');

    LatexCmds.larr = LatexCmds.leftarrow = bind(VanillaSymbol, '\\leftarrow ', '&larr;');

    LatexCmds.impliedby = bind(BinaryOperator, '\\Leftarrow ', '&lArr;');

    LatexCmds.lArr = LatexCmds.Leftarrow = bind(VanillaSymbol, '\\Leftarrow ', '&lArr;');

    LatexCmds.harr = LatexCmds.lrarr = LatexCmds.leftrightarrow = bind(VanillaSymbol, '\\leftrightarrow ', '&harr;');

    LatexCmds.iff = bind(BinaryOperator, '\\Leftrightarrow ', '&hArr;');

    LatexCmds.hArr = LatexCmds.lrArr = LatexCmds.Leftrightarrow = bind(VanillaSymbol, '\\Leftrightarrow ', '&hArr;');

    LatexCmds.Re = LatexCmds.Real = LatexCmds.real = bind(VanillaSymbol, '\\Re ', '&real;');

    LatexCmds.Im = LatexCmds.imag = LatexCmds.image = LatexCmds.imagin = LatexCmds.imaginary = LatexCmds.Imaginary = bind(VanillaSymbol, '\\Im ', '&image;');

    LatexCmds.part = LatexCmds.partial = bind(VanillaSymbol, '\\partial ', '&part;');

    LatexCmds.inf = LatexCmds.infin = LatexCmds.infty = LatexCmds.infinity = bind(VanillaSymbol, '\\infty ', '&infin;');

    LatexCmds.alef = LatexCmds.alefsym = LatexCmds.aleph = LatexCmds.alephsym = bind(VanillaSymbol, '\\aleph ', '&alefsym;');

    LatexCmds.xist = //LOL
    LatexCmds.xists = LatexCmds.exist = LatexCmds.exists = bind(VanillaSymbol, '\\exists ', '&exist;');

    LatexCmds.and = LatexCmds.land = LatexCmds.wedge = bind(VanillaSymbol, '\\wedge ', '&and;');

    LatexCmds.or = LatexCmds.lor = LatexCmds.vee = bind(VanillaSymbol, '\\vee ', '&or;');

    LatexCmds.o = LatexCmds.O = LatexCmds.empty = LatexCmds.emptyset = LatexCmds.oslash = LatexCmds.Oslash = LatexCmds.nothing = LatexCmds.varnothing = bind(BinaryOperator, '\\varnothing ', '&empty;');

    LatexCmds.cup = LatexCmds.union = bind(BinaryOperator, '\\cup ', '&cup;');

    LatexCmds.cap = LatexCmds.intersect = LatexCmds.intersection = bind(BinaryOperator, '\\cap ', '&cap;');

    LatexCmds.deg = LatexCmds.degree = bind(VanillaSymbol, '^\\circ ', '&deg;');

    LatexCmds.ang = LatexCmds.angle = bind(VanillaSymbol, '\\angle ', '&ang;');


    var NonItalicizedFunction = P(Symbol, function (_, _super) {
        _.init = function (fn) {
            _super.init.call(this, '\\' + fn + ' ', '<span>' + fn + '</span>');
        };
        _.respace = function () {
            this.jQ[0].className = (this[R] instanceof SupSub || this[R] instanceof Bracket) ? '' : 'non-italicized-function';
        };
    });

    LatexCmds.ln = LatexCmds.lg = LatexCmds.log = LatexCmds.span = LatexCmds.proj = LatexCmds.det = LatexCmds.dim = LatexCmds.min = LatexCmds.max = LatexCmds.mod = LatexCmds.lcm = LatexCmds.gcd = LatexCmds.gcf = LatexCmds.hcf = LatexCmds.lim = NonItalicizedFunction;

    (function () {
        var trig = ['sin', 'cos', 'tan', 'sec', 'cosec', 'csc', 'cotan', 'cot'];
        for (var i in trig) {
            LatexCmds[trig[i]] = LatexCmds[trig[i] + 'h'] = LatexCmds['a' + trig[i]] = LatexCmds['arc' + trig[i]] = LatexCmds['a' + trig[i] + 'h'] = LatexCmds['arc' + trig[i] + 'h'] = NonItalicizedFunction;
        }
    }());

    // Parser MathCommand
    var latexMathParser = (function () {
        function commandToBlock(cmd) {
            var block = MathBlock();
            cmd.adopt(block, 0, 0);
            return block;
        }

        function joinBlocks(blocks) {
            var firstBlock = blocks[0] || MathBlock();

            for (var i = 1; i < blocks.length; i += 1) {
                blocks[i].children().adopt(firstBlock, firstBlock.ends[R], 0);
            }

            return firstBlock;
        }

        var string = Parser.string;
        var regex = Parser.regex;
        var letter = Parser.letter;
        var any = Parser.any;
        var optWhitespace = Parser.optWhitespace;
        var succeed = Parser.succeed;
        var fail = Parser.fail;

        // Parsers yielding MathCommands
        var variable = letter.map(Variable);
        var symbol = regex(/^[^${}\\_^]/).map(VanillaSymbol);

        var controlSequence = regex(/^[^\\a-eg-zA-Z]/) // hotfix #164; match MathBlock::write
        .or(string('\\').then(
        regex(/^[a-z]+/i).or(regex(/^\s+/).result(' ')).or(regex(/^[\\\\]/).result('enter')).or(regex(/^[\\,]/).result('thinspace')).or(regex(/^[\\;]/).result('thickspace')).or(regex(/^[\\:]/).result('mediumspace')).or(any))).then(function (ctrlSeq) {
            //var result = regex(/^[\\,|\\\:]/).then;
            var cmdKlass = LatexCmds[ctrlSeq];
            if (cmdKlass) {
                return cmdKlass(ctrlSeq).parser();
            } else {
                return fail('unknown command: \\' + ctrlSeq);
            }

        });
        //cases command
        var casesCommand = regex(/^\\begin{cases}/).then(regex(/^(.*?)\\end{cases}/)).then(function (a) {
            // Strip out the trailing command (\end{cases})
            
            var content = a.replace(/\\end{cases}/, '');

            // Retrieve the cases command
            var cmd = LatexCmds.cases();

            // Parse the individual blocks within the cases
            // Refer to http://en.wikibooks.org/wiki/LaTeX/Mathematics to learn more about the LaTeX
            // cases notation.
            // Basically rows are delimited by double backslashes and columns by ampersands
            var blocks = [];
            var rows = content.split('\\\\');
            for (var i = 0; i < rows.length; i++) {
                // We have a row, now split it into its respective columns
                var columns = rows[i].split('&');
                for (var a = 0; a < columns.length; a++) {
                    // Parse the individual block, this block may contain other more complicated commands
                    // like a square root, we delegate the parsing of this to the Parser object. It returns
                    // a MathElement block object which is the object representation of the formula.
                    var block = latexMathParser.parse(columns[a]);
                    blocks.push(block);
                }
            }

            // Tell our Latex.cases command how big our cases is, recall that casesSize is simply an
            // alias for LatexCmds.cases.setSize
            CasesSize(rows.length, columns.length);

            // Attach the child blocks (each element of the cases) to the parent cases object
            cmd.blocks = blocks;
            for (var i = 0; i < blocks.length; i += 1) {
                blocks[i].adopt(cmd, cmd.ends[R], 0);
            }
            // The block elements attached to a command are each rendered and then they replace the
            // '&0', '&1', '&2', '&3'... placeholders that are found within the command's htmlTemplate
            // Return the Latex.cases() object to the main parser so that it knows to render this
            // particular portion of latex in this fashion
            return Parser.succeed(cmd);
        });
        //matrix command
        var matrixCommand = regex(/^\\begin{matrix}/).then(regex(/^(.*?)\\end{matrix}/)).then(function (a) {
            // Strip out the trailing command (\end{matrix})          
            var content = a.replace(/\\end{matrix}/, '');

            // Retrieve the matrix command
            var cmd = LatexCmds.matrix();

            // Parse the individual blocks within the matrix
            // Refer to http://en.wikibooks.org/wiki/LaTeX/Mathematics to learn more about the LaTeX
            // matrix notation.
            // Basically rows are delimited by double backslashes and columns by ampersands
            var blocks = [];
            var rows = content.split('\\\\');
            for (var i = 0; i < rows.length; i++) {
                // We have a row, now split it into its respective columns
                var columns = rows[i].split('&');
                for (var a = 0; a < columns.length; a++) {
                    // Parse the individual block, this block may contain other more complicated commands
                    // like a square root, we delegate the parsing of this to the Parser object. It returns
                    // a MathElement block object which is the object representation of the formula.
                    var block = latexMathParser.parse(columns[a]);
                    blocks.push(block);
                }
            }

            // Tell our Latex.matrix command how big our matrix is, recall that MatrixSize is simply an
            // alias for LatexCmds.matrix.setSize
            MatrixSize(rows.length, columns.length);

            // Attach the child blocks (each element of the matrix) to the parent matrix object
             cmd.blocks = blocks;
            //alert(blockmatrixTemp.ends[R]);
                for (var i = 0; i < blocks.length; i += 1) {
                    
                    blocks[i].adopt(cmd, cmd.ends[R], 0);
                }
        
            // The block elements attached to a command are each rendered and then they replace the
            // '&0', '&1', '&2', '&3'... placeholders that are found within the command's htmlTemplate
            // Return the Latex.matrix() object to the main parser so that it knows to render this
            // particular portion of latex in this fashion
            return Parser.succeed(cmd);
        });

        var command = controlSequence.or(casesCommand).or(matrixCommand).or(variable).or(symbol);

        // Parsers yielding MathBlocks
        var mathGroup = string('{').then(function () {
            return mathSequence;
        }).skip(string('}'));
        var mathBlock = optWhitespace.then(mathGroup.or(command.map(commandToBlock)));
        var mathSequence = mathBlock.many().map(joinBlocks).skip(optWhitespace);

        var optMathBlock = string('[').then(
        mathBlock.then(function (block) {
            return block.join('latex') !== ']' ? succeed(block) : fail();
        }).many().map(joinBlocks).skip(optWhitespace)).skip(string(']'));

        var latexMath = mathSequence;

        latexMath.block = mathBlock;
        latexMath.optBlock = optMathBlock;
        return latexMath;
    })();
    /********************************************
     * Cursor and Selection "singleton" classes
     *******************************************/

/* The main thing that manipulates the Math DOM. Makes sure to manipulate the
    HTML DOM to match. */

/* Sort of singletons, since there should only be one per editable math
    textbox, but any one HTML document can contain many such textboxes, so any one
    JS environment could actually contain many instances. */

    //A fake cursor in the fake textbox that the math is rendered in.
    var Cursor = P(Point, function (_) {
        _.init = function (root) {
            this.parent = this.root = root;
            var jQ = this.jQ = this._jQ = $('<span class="cursor">&zwj;</span>');

            //closured for setInterval
            this.blink = function () {
                jQ.toggleClass('blink');
            };

            this.upDownCache = {};
        };

        _.show = function () {
            this.jQ = this._jQ.removeClass('blink');
            if ('intervalId' in this) //already was shown, just restart interval
            clearInterval(this.intervalId);
            else { //was hidden and detached, insert this.jQ back into HTML DOM
                if (this[R]) {
                    if (this.selection && this.selection.ends[L][L] === this[L]) this.jQ.insertBefore(this.selection.jQ);
                    else this.jQ.insertBefore(this[R].jQ.first());
                } else this.jQ.appendTo(this.parent.jQ);
                this.parent.focus();
            }
            this.intervalId = setInterval(this.blink, 500);
            return this;
        };
        _.hide = function () {
            if ('intervalId' in this) clearInterval(this.intervalId);
            delete this.intervalId;
            this.jQ.detach();
            this.jQ = $();
            return this;
        };

        _.withDirInsertAt = function (dir, parent, withDir, oppDir) {
            var oldParent = this.parent;
            this.parent = parent;
            this[dir] = withDir;
            this[-dir] = oppDir;
            oldParent.blur();
        };
        _.insDirOf = function (dir, el) {
            prayDirection(dir);
            this.withDirInsertAt(dir, el.parent, el[dir], el);
            this.parent.jQ.addClass('hasCursor');
            this.jQ.insDirOf(dir, el.jQ);
            return this;
        };
        _.insLeftOf = function (el) {
            return this.insDirOf(L, el);
        };
        _.insRightOf = function (el) {
            return this.insDirOf(R, el);
        };

        _.insAtDirEnd = function (dir, el) {
            prayDirection(dir);
            this.withDirInsertAt(dir, el, 0, el.ends[dir]);

            // never insert before textarea
            if (dir === L && el.textarea) {
                this.jQ.insDirOf(-dir, el.textarea);
            } else {
                this.jQ.insAtDirEnd(dir, el.jQ);
            }

            el.focus();

            return this;
        };
        _.insAtLeftEnd = function (el) {
            return this.insAtDirEnd(L, el);
        };
        _.insAtRightEnd = function (el) {
            return this.insAtDirEnd(R, el);
        };

        _.hopDir = function (dir) {
            prayDirection(dir);

            this.jQ.insDirOf(dir, this[dir].jQ);
            this[-dir] = this[dir];
            this[dir] = this[dir][dir];
            return this;
        };
        _.hopLeft = function () {
            return this.hopDir(L);
        };
        _.hopRight = function () {
            return this.hopDir(R);
        };

        _.moveDirWithin = function (dir, block) {
            prayDirection(dir);

            if (this[dir]) {
                if (this[dir].ends[-dir]) this.insAtDirEnd(-dir, this[dir].ends[-dir]);
                else this.hopDir(dir);
            } else {
                // we're at the beginning/end of the containing block, so do nothing
                if (this.parent === block) return;

                if (this.parent[dir]) this.insAtDirEnd(-dir, this.parent[dir]);
                else this.insDirOf(dir, this.parent.parent);
            }
        };
        _.moveLeftWithin = function (block) {
            return this.moveDirWithin(L, block);
        };
        _.moveRightWithin = function (block) {
            return this.moveDirWithin(R, block);
        };
        _.moveDir = function (dir) {
            prayDirection(dir);

            clearUpDownCache(this);

            if (this.selection) {
                this.insDirOf(dir, this.selection.ends[dir]).clearSelection();
            } else {
                this.moveDirWithin(dir, this.root);
            }

            return this.show();
        };
        _.moveLeft = function () {
            return this.moveDir(L);
        };
        _.moveRight = function () {
            return this.moveDir(R);
        };

        /**
         * moveUp and moveDown have almost identical algorithms:
         * - first check left and right, if so insAtLeft/RightEnd of them
         * - else check the parent's 'up'/'down' property - if it's a function,
         *   call it with the cursor as the sole argument and use the return value.
         *
         *   Given undefined, will bubble up to the next ancestor block.
         *   Given false, will stop bubbling.
         *   Given a MathBlock,
         *     + moveUp will insAtRightEnd of it
         *     + moveDown will insAtLeftEnd of it
         *
         */
        _.moveUp = function () {
            return moveUpDown(this, 'up');
        };
        _.moveDown = function () {
            return moveUpDown(this, 'down');
        };

        function moveUpDown(self, dir) {
            if (self[R][dir]) self.insAtLeftEnd(self[R][dir]);
            else if (self[L][dir]) self.insAtRightEnd(self[L][dir]);
            else {
                var ancestorBlock = self.parent;
                do {
                    var prop = ancestorBlock[dir];
                    if (prop) {
                        if (typeof prop === 'function') prop = ancestorBlock[dir](self);
                        if (prop === false || prop instanceof MathBlock) {
                            self.upDownCache[ancestorBlock.id] = Point(self.parent, self[L], self[R]);

                            if (prop instanceof MathBlock) {
                                var cached = self.upDownCache[prop.id];

                                if (cached) {
                                    if (cached[R]) {
                                        self.insLeftOf(cached[R]);
                                    } else {
                                        self.insAtRightEnd(cached.parent);
                                    }
                                } else {
                                    var pageX = offset(self).left;
                                    self.insAtRightEnd(prop);
                                    self.seekHoriz(pageX, prop);
                                }
                            }
                            break;
                        }
                    }
                    ancestorBlock = ancestorBlock.parent.parent;
                } while (ancestorBlock);
            }

            return self.clearSelection().show();
        }

        _.seek = function (target, pageX, pageY) {
            clearUpDownCache(this);
            var cmd, block, cursor = this.clearSelection().show();
            if (target.hasClass('empty')) {
                cursor.insAtLeftEnd(MathElement[target.attr(mqBlockId)]);
                return cursor;
            }

            cmd = MathElement[target.attr(mqCmdId)];
            if (cmd instanceof Symbol) { //insert at whichever side is closer
                if (target.outerWidth() > 2 * (pageX - target.offset().left)) cursor.insLeftOf(cmd);
                else cursor.insRightOf(cmd);

                return cursor;
            }
            if (!cmd) {
                block = MathElement[target.attr(mqBlockId)];
                if (!block) { //if no MathQuill data, try parent, if still no, just start from the root
                    target = target.parent();
                    cmd = MathElement[target.attr(mqCmdId)];
                    if (!cmd) {
                        block = MathElement[target.attr(mqBlockId)];
                        if (!block) block = cursor.root;
                    }
                }
            }

            if (cmd) cursor.insRightOf(cmd);
            else cursor.insAtRightEnd(block);

            return cursor.seekHoriz(pageX, cursor.root);
        };
        _.seekHoriz = function (pageX, block) {
            //move cursor to position closest to click
            var cursor = this;
            var dist = offset(cursor).left - pageX;
            var leftDist;

            do {
                cursor.moveLeftWithin(block);
                leftDist = dist;
                dist = offset(cursor).left - pageX;
            }
            while (dist > 0 && (cursor[L] || cursor.parent !== block));

            if (-dist > leftDist) cursor.moveRightWithin(block);

            return cursor;
        };

        function offset(self) {
            //in Opera 11.62, .getBoundingClientRect() and hence jQuery::offset()
            //returns all 0's on inline elements with negative margin-right (like
            //the cursor) at the end of their parent, so temporarily remove the
            //negative margin-right when calling jQuery::offset()
            //Opera bug DSK-360043
            //http://bugs.jquery.com/ticket/11523
            //https://github.com/jquery/jquery/pull/717
            var offset = self.jQ.removeClass('cursor').offset();
            self.jQ.addClass('cursor');
            return offset;
        }
        _.writeLatex = function (latex) {
            var self = this;
            clearUpDownCache(self);
            self.show().deleteSelection();

            var all = Parser.all;
            var eof = Parser.eof;

            var block = latexMathParser.skip(eof).or(all.result(false)).parse(latex);

            if (block) {
                block.children().adopt(self.parent, self[L], self[R]);
                MathElement.jQize(block.join('html')).insertBefore(self.jQ);
                self[L] = block.ends[R];
                block.finalizeInsert();
                self.parent.bubble('redraw');
            }

            return this.hide();
        };
        _.write = function (ch) {
            var seln = this.prepareWrite();
            return this.insertCh(ch, seln);
        };
        _.insertCh = function (ch, replacedFragment) {
            this.parent.write(this, ch, replacedFragment);
            return this;
        };
        _.insertCmd = function (latexCmd, replacedFragment) {
            var cmd = LatexCmds[latexCmd];
            if (cmd) {
                cmd = cmd(latexCmd);
                if (replacedFragment) cmd.replaces(replacedFragment);
                cmd.createLeftOf(this);
            } else {
                cmd = TextBlock();
                cmd.replaces(latexCmd);
                cmd.ends[L].focus = function () {
                    delete this.focus;
                    return this;
                };
                cmd.createLeftOf(this);
                this.insRightOf(cmd);
                if (replacedFragment) replacedFragment.remove();
            }
            return this;
        };
        _.unwrapGramp = function () {
            var gramp = this.parent.parent;
            var greatgramp = gramp.parent;
            var rightward = gramp[R];
            var cursor = this;

            var leftward = gramp[L];
            gramp.disown().eachChild(function (uncle) {
                if (uncle.isEmpty()) return;

                uncle.children().adopt(greatgramp, leftward, rightward).each(function (cousin) {
                    cousin.jQ.insertBefore(gramp.jQ.first());
                });

                leftward = uncle.ends[R];
            });

            if (!this[R]) { //then find something to be rightward to insLeftOf
                if (this[L]) this[R] = this[L][R];
                else {
                    while (!this[R]) {
                        this.parent = this.parent[R];
                        if (this.parent) this[R] = this.parent.ends[L];
                        else {
                            this[R] = gramp[R];
                            this.parent = greatgramp;
                            break;
                        }
                    }
                }
            }
            if (this[R]) this.insLeftOf(this[R]);
            else this.insAtRightEnd(greatgramp);

            gramp.jQ.remove();

            if (gramp[L]) gramp[L].respace();
            if (gramp[R]) gramp[R].respace();
        };
        _.deleteDir = function (dir) {
            prayDirection(dir);
            clearUpDownCache(this);
            this.show();

            if (this.deleteSelection()); // pass
            else if (this[dir]) {
                if (this[dir].isEmpty()) this[dir] = this[dir].remove()[dir];
                else this.selectDir(dir);
            } else if (this.parent !== this.root) {
                if (this.parent.parent.isEmpty()) return this.insDirOf(-dir, this.parent.parent).deleteDir(dir);
                else this.unwrapGramp();
            }

            if (this[L]) this[L].respace();
            if (this[R]) this[R].respace();
            this.parent.bubble('redraw');

            return this;
        };
        _.backspace = function () {
            return this.deleteDir(L);
        };
        _.deleteForward = function () {
            return this.deleteDir(R);
        };
        _.selectFrom = function (anticursor) {
            //find ancestors of each with common parent
            var oneA = this,
                otherA = anticursor; //one ancestor, the other ancestor
            loopThroughAncestors: while (true) {
                for (var oneI = this; oneI !== oneA.parent.parent; oneI = oneI.parent.parent) //one intermediate, the other intermediate
                if (oneI.parent === otherA.parent) {
                    left = oneI;
                    right = otherA;
                    break loopThroughAncestors;
                }

                for (var otherI = anticursor; otherI !== otherA.parent.parent; otherI = otherI.parent.parent)
                if (oneA.parent === otherI.parent) {
                    left = oneA;
                    right = otherI;
                    break loopThroughAncestors;
                }

                if (oneA.parent.parent) oneA = oneA.parent.parent;
                if (otherA.parent.parent) otherA = otherA.parent.parent;
            }
            //figure out which is leftward and which is rightward
            var left, right, leftRight;
            if (left[R] !== right) {
                for (var rightward = left; rightward; rightward = rightward[R]) {
                    if (rightward === right[L]) {
                        leftRight = true;
                        break;
                    }
                }
                if (!leftRight) {
                    leftRight = right;
                    right = left;
                    left = leftRight;
                }
            }
            this.hide().selection = Selection(left[L][R] || left.parent.ends[L], right[R][L] || right.parent.ends[R]);
            this.insRightOf(right[R][L] || right.parent.ends[R]);
            this.root.selectionChanged();
        };
        _.selectDir = function (dir) {
            prayDirection(dir);
            clearUpDownCache(this);

            if (this.selection) {
                // if cursor is at the (dir) edge of selection
                if (this.selection.ends[dir] === this[-dir]) {
                    // then extend (dir) if possible
                    if (this[dir]) this.hopDir(dir).selection.extendDir(dir);
                    // else level up if possible
                    else if (this.parent !== this.root) {
                        this.insDirOf(dir, this.parent.parent).selection.levelUp();
                    }
                }
                // else cursor is at the (-dir) edge of selection, retract if possible
                else {
                    this.hopDir(dir);

                    // clear the selection if we only have one thing selected
                    if (this.selection.ends[dir] === this.selection.ends[-dir]) {
                        this.clearSelection().show();
                        return;
                    }

                    this.selection.retractDir(dir);
                }
            }
            // no selection, create one
            else {
                if (this[dir]) this.hopDir(dir);
                // else edge of a block
                else {
                    if (this.parent === this.root) return;

                    this.insDirOf(dir, this.parent.parent);
                }

                this.hide().selection = Selection(this[-dir]);
            }

            this.root.selectionChanged();
        };
        _.selectLeft = function () {
            return this.selectDir(L);
        };
        _.selectRight = function () {
            return this.selectDir(R);
        };

        function clearUpDownCache(self) {
            self.upDownCache = {};
        }

        _.prepareMove = function () {
            clearUpDownCache(this);
            return this.show().clearSelection();
        };
        _.prepareEdit = function () {
            clearUpDownCache(this);
            return this.show().deleteSelection();
        };
        _.prepareWrite = function () {
            clearUpDownCache(this);
            return this.show().replaceSelection();
        };

        _.clearSelection = function () {
            if (this.selection) {
                this.selection.clear();
                delete this.selection;
                this.root.selectionChanged();
            }
            return this;
        };
        _.deleteSelection = function () {
            if (!this.selection) return false;

            this[L] = this.selection.ends[L][L];
            this[R] = this.selection.ends[R][R];
            this.selection.remove();
            this.root.selectionChanged();
            return delete this.selection;
        };
        _.replaceSelection = function () {
            var seln = this.selection;
            if (seln) {
                this[L] = seln.ends[L][L];
                this[R] = seln.ends[R][R];
                delete this.selection;
            }
            return seln;
        };
    });

    var Selection = P(MathFragment, function (_, _super) {
        _.init = function () {
            var frag = this;
            _super.init.apply(frag, arguments);

            frag.jQwrap(frag.jQ);
        };
        _.jQwrap = function (children) {
            this.jQ = children.wrapAll('<span class="selection"></span>').parent();
            //can't do wrapAll(this.jQ = $(...)) because wrapAll will clone it
        };
        _.adopt = function () {
            this.jQ.replaceWith(this.jQ = this.jQ.children());
            return _super.adopt.apply(this, arguments);
        };
        _.clear = function () {
            this.jQ.replaceWith(this.jQ.children());
            return this;
        };
        _.levelUp = function () {
            var seln = this,
                gramp = seln.ends[L] = seln.ends[R] = seln.ends[R].parent.parent;
            seln.clear().jQwrap(gramp.jQ);
            return seln;
        };
        _.extendDir = function (dir) {
            prayDirection(dir);
            this.ends[dir] = this.ends[dir][dir];
            this.ends[dir].jQ.insAtDirEnd(dir, this.jQ);
            return this;
        };
        _.extendLeft = function () {
            return this.extendDir(L);
        };
        _.extendRight = function () {
            return this.extendDir(R);
        };

        _.retractDir = function (dir) {
            prayDirection(dir);
            this.ends[-dir].jQ.insDirOf(-dir, this.jQ);
            this.ends[-dir] = this.ends[-dir][dir];
        };
        _.retractRight = function () {
            return this.retractDir(R);
        };
        _.retractLeft = function () {
            return this.retractDir(L);
        };
    });
    /*********************************************************
     * The actual jQuery plugin and document ready handlers.
     ********************************************************/

    //The publicy exposed method of jQuery.prototype, available (and meant to be
    //called) on jQuery-wrapped HTML DOM elements.
    jQuery.fn.mathquill = function (cmd, latex,jump) {
        switch (cmd) {
        case 'redraw':
            return this.each(function () {
                var blockId = $(this).attr(mqBlockId),
                    rootBlock = blockId && MathElement[blockId];
                if (rootBlock) {
                    (function postOrderRedraw(el) {
                        el.eachChild(postOrderRedraw);
                        if (el.redraw) el.redraw();
                    }(rootBlock));
                }
            });
        case 'revert':
            return this.each(function () {
                var blockId = $(this).attr(mqBlockId),
                    block = blockId && MathElement[blockId];
                if (block && block.revert) block.revert();
            });
        case 'latex':
            if (arguments.length > 1) {
                return this.each(function () {
                    var blockId = $(this).attr(mqBlockId),
                        block = blockId && MathElement[blockId];
                    if (block) block.renderLatex(latex);
                });
            }

            var blockId = $(this).attr(mqBlockId),
                block = blockId && MathElement[blockId];
                 blockmatrixTemp=[];
                matrixString='';
                sizematrix=0;
                sizecases=0;
                caseString='';
            return block && block.latex();
        case 'text':
            var blockId = $(this).attr(mqBlockId),
                block = blockId && MathElement[blockId];
            return block && block.text();
        case 'html':
            return this.html().replace(/ ?hasCursor|hasCursor /, '').replace(/ class=(""|(?= |>))/g, '').replace(/<span class="?cursor( blink)?"?><\/span>/i, '').replace(/<span class="?textarea"?><textarea><\/textarea><\/span>/i, '');
        case 'write':
            if (arguments.length > 1) return this.each(function () {
                var blockId = $(this).attr(mqBlockId),
                    block = blockId && MathElement[blockId],
                    cursor = block && block.cursor;

                if (cursor) cursor.writeLatex(latex).parent.blur();
                if(typeof(jump)=="undefined"){
                    cursor.moveRight();
                }
                else{
                    while(jump<0){
                        cursor.moveDir(-1);
                        jump++;                       
                    }
                }
                blockmatrixTemp=[];
                matrixString='';
                sizematrix=0;
                sizecases=0;
                caseString='';
            });
        case 'cmd':
            if (arguments.length > 1) return this.each(function () {
                var blockId = $(this).attr(mqBlockId),
                    block = blockId && MathElement[blockId],
                    cursor = block && block.cursor;

                if (cursor) {
                    var seln = cursor.prepareWrite();
                    if (/^\\[a-z]+$/i.test(latex)) cursor.insertCmd(latex.slice(1), seln);
                    else cursor.insertCh(latex, seln);
                    cursor.hide().parent.blur();
                }
            });
        default:
            var textbox = cmd === 'textbox',
                editable = textbox || cmd === 'editable',
                RootBlock = textbox ? RootTextBlock : RootMathBlock;
            return this.each(function () {
                createRoot($(this), RootBlock(), textbox, editable);
            });
        }
    };

    //on document ready, mathquill-ify all `<tag class="mathquill-*">latex</tag>`
    //elements according to their CSS class.
    jQuery(function () {
        jQuery('.mathquill-editable:not(.mathquill-rendered-math)').mathquill('editable');
        jQuery('.mathquill-textbox:not(.mathquill-rendered-math)').mathquill('textbox');
        jQuery('.mathquill-embedded-latex').mathquill();
    });


}());